Case 18/0: the verb that reported a record it never wrote

🕵️ Show the full case file → 📋 Session protocol →

Case File · Code Homicide Dept.

I asked the project to register a task. The command answered "New backlog item: bl-044", with its identifier, its title and its priority. The action log booked it as a write. The manual, from the repository's very first day, promised "create new item". I wrote that identifier into a governed record that now pointed at it. And only much later, while drafting something else, did I ask the store for its last item. It answered bl-043. I ran git diff --stat over the file: zero lines. The record did not exist, had never existed, and three different surfaces had confirmed to me that it did.

The double ledger — what it cost, and what it left

The suspects — the false leads

The weapon — Eighteen statements that print, and two more surfaces repeating it.

# modules/backlog.nu — the tail of `backlog add`, as it stood.
# Eighteen statements. All print. None touches the disk.

  print $"New backlog item: ($new_id)"
  print "Add to reflection/backlog.ncl:"
  print $"    id       = \"($new_id)\","
  ...

# And the other two surfaces, saying the same without having looked either:

  bin/ontoref.nu:916   log-action $"backlog add ($title)" "write"
  nulib/help.nu:140    "create new item"

# The sibling right next to it, in the same module, DID write:

  modules/backlog.nu:268   def backlog-set-status   ← done and cancel patch the file

# Three agreeing assertions. Zero reads of the store.
# An agent checking any one of the three against another came away just as convinced.

The identifier was computed as the maximum plus one over the existing ones. With no write, two consecutive sessions receive the same one. The command did not merely fail to create: it handed the same number to whoever asked.

The turn — It writes, and then submits itself to the store.

# 1. It writes. And then it does NOT believe itself: it re-reads the store and
#    demands to see itself in it. This is adr-066 — the check decides, never the
#    reporter — applied to a VERB instead of to a mode's step.

  let landed = (backlog-load | where id == $new_id)
  if ($landed | is-empty) {
    error make {
      msg: $"backlog add: ($file) was written and ($new_id) is NOT in it when re-read —
        refusing to report a creation the store does not confirm"
    }
  }

# 2. And before replacing anything, the store's own contract decides:

  $patched | save -f $candidate            # beside it, never over it
  let check = (do { ^nickel export $candidate } | complete)
  if $check.exit_code != 0 {
    rm -f $candidate                       # the store never finds out
    error make { msg: $"...NOTHING was written. nickel said: ($check.stderr)" }
  }
  mv -f $candidate $file

# The action log now receives the act that actually happens, not the one intended.

The refusals were tested against what they must refuse, not only against what they must accept: a kind outside the enum, and a title containing %{. In both, the file was left untouched, with the same digest, and with no orphaned candidates.

The verdict

The series asks: with ontoref, would it have gone like this? And this case answers that the rule already existed and was already running. ADR-066 states, at Hard severity, that a step declaring a check does not decide its own status: the exit code does, and a self-report contradicting it is refused. It is accepted, it carries its typed check, and it runs over every step of every mode in this project. What this case file finds is not an absence: it is a frontier. The rule begins when a mode starts, and an agent types verbs long before that. On the far side of that frontier, the verb certified itself with exactly the ease with which, on the near side, it was forbidden to. And there is something worse than one surface lying, which is three corroborating each other: the message, the audit log and the manual said the same thing from the repository’s first commit, so any check between them returned coherence. The drift was not detectable by comparing declarations. It was detectable only by asking the store — which is exactly what a success message persuades everyone not to do.

The reconstruction — the session, replayed with protocol

What was asked — reconstructed from refs:sessions/2026-08-05-assess-signal-y-el-verbo — a bounded excerpt held in custody. NOT the session's opening prompt: it is the one that opened the work where the drift happened, which is what a replay reconstructs. Typos preserved: a corrected quotation stops being collatable. Session identified by the work — 71 mentions of `backlog add`. The prompt stays in Spanish: it is a quotation.

además el backlog add noe es del todos correcto, tiene carencias ¿ no ¿

What should have been asked

A verb says it writes. Before believing it, look at the file.

1. Check against the ARTEFACT, not against another surface. Three mutually coherent surfaces are not three confirmations: they can be one error repeated.
2. A verb that claims to write is verified with `git diff` or the file's mtime, never with its own output message.
3. If the system has an action log, ask who EMITS the entry: an entry written ALONGSIDE the write can record a mutation that never happened.
4. And when you find one, do not fix it alone: count how many verbs claim the same. One is a typo; the number tells you whether it is a case.

The gate before delegating: Before accepting «done» from a verb that claims to write, the command that checks THE FILE must be written down. It was not, and the drift survived for exactly that reason: it was not contradictory, it was consistent — message, log and manual all said the same thing, and none of them had looked at disk. A contrast between surfaces derived from one another is not a witness: it is the same error quoted three times.

The ADR trigger: Yes, and it is still undeclared as a constraint: that the action-log entry be EMITTED BY the write rather than written beside it. While they stay separate, a mutation that does not happen can still be logged — and that is this case, not its anecdote. Address: bl-045.

Case law — what enforces the lesson today

• ✓
  Whoever executes does not certify: the state is decided by the check, and a self-report contradicting it is refusedadr:066/check-decides-never-reporter
• ✓
  An item that would break the store's contract is refused before the file is replaced, and the store never finds outcontract:.ontoref/reflection/schemas/backlog.ncl#kind

⊘Declared debt: Nothing compares a verb that declares a write against whether it writes. The dispatcher makes 233 action-log calls, 65 of them declare a write, and the 2026-08-05 audit found two that mutate nothing; both were corrected by hand and nothing prevents the third. What would settle it: the log entry being EMITTED BY the write rather than sitting beside it, so a mutation that does not happen cannot be recorded. Address: bl-045.