---
name: a-lost-continuation-backslash-compiles-and-passes
description: "A Rust multi-line string literal that loses its line-continuation backslash bakes the source indentation into the RENDERED text — it compiles, every test passes, and only a rendered-text gate sees it."
metadata: 
  node_type: memory
  type: project
  originSessionId: ce86e2f4-9819-4bde-b3e1-03d891562bf2
  modified: 2026-08-29T11:17:58.349Z
---

A Rust string literal split across lines needs a trailing `\` to eat the newline
and the next line's indentation. **Lose that backslash and the literal still
compiles, still type-checks, and still passes every test — the only thing that
changes is the text a human reads**, which now carries a run of source-indent
spaces in the middle of a sentence.

**Measured 2026-08-28, CONDUIT W3 (releases#234).** My `IO_EVENTS_NO_CURSOR`
diagnostic lost its backslashes when a tool wrote the file. `xtask check` caught
it: *"2 interior space runs in operator-facing text … run of 14 spaces"*. Windows
clippy, Linux clippy, three nextest legs and `traceable-reqs check` were ALL
green at that same sha. `cat -A` is what confirmed the fix — the backslashes are
visible at line ends or they are not there.

**Why no test can catch it, structurally:** tests assert on VALUES and on
substrings. Nothing asserts a diagnostic's exact rendering, because pinning every
operator string in an assertion is a maintenance cost the project has
deliberately refused. So this defect class lives precisely in the gap tests do
not cover, and the rendered-text gate is not a formality — it is the ONLY
instrument that sees it. **Never treat an `xtask check` red as noise beside eight
green legs; it is looking at something none of them look at.**

**Writing tools eat backslashes.** The loss happened in a heredoc → Python
string → file chain where `\\` should have survived and did not. If a literal
must span lines, write it and then VERIFY with `cat -A` / `sed -n 'N,Mp' | cat -A`
rather than trusting the write. `xtask check`'s own message names the mechanism
("usually a Rust line-continuation backslash that was eaten"), which means this
has bitten the project before.

**The exemption exists but needs a token:** `spacerun-ok: <token> — <reason>` on
the literal's opening line (or the comment directly above, when the opening line
must end in the backslash). A bare marker exempts nothing — the token is what
lets one decision with many sites be re-audited later.

**SECOND FACE — the REPAIR mints its own variant (todlando testimony, W1 #235,
2026-08-29):** fixing round 1, his tool wrote **`\` + literal `r` + LF** instead
of `\`+CRLF. Rust parses that as a `\r` CARRIAGE-RETURN ESCAPE followed by a raw
newline INSIDE the literal — valid Rust, compiles, clippy clean, 3/3 rig cells
green, renders broken across three lines. So the class has two spellings: the
backslash LOST (round 1) and the backslash's continuation BYTES WRONG (round 2),
and both defeat source-reading, because the source LOOKS repaired. What caught
round 2: render with `--no-capture` and read emitted BYTES, then **byte-diff the
continuation against an EXISTING known-good site in the same file** (his anchor:
`SPAWN_ZOMBIE_REAP`, `\`+CR+LF) and assert byte-equality instead of eyeballing.
In a CRLF checkout the correct sequence is `\`+CR+LF, which is exactly why
hand-verifying "backslash at end of line" with eyes or grep passes the broken
form. Verify a continuation repair by byte comparison to the file's own
convention, never by re-reading the source you just wrote.

Kin: [[string-census-pattern-encodes-an-assumption]] (the same backslash, seen
from the census side — `rg -U` for a token split across lines),
[[clippy-compiles-it-does-not-run-tests]] (the sibling claim: an instrument that
builds is not an instrument that checks),
[[retraction-sweeps-diagnostic-strings]].

**NEW FACE, 2026-09-09 (releases#289): the tool that writes the file is a source of this defect,
and the repo already owns the instrument that catches it.** Patching Rust through a python heredoc
collapsed the `\` + newline of FIVE literals into interior space runs (four `cli.rs` operator lines
plus an assert message). It compiled; nothing failed. I caught them by reading the emitted BYTES
after each patch, and rebuilt each backslash with `chr(92)` rather than typing one into the heredoc.

The detector that would have caught it anyway is `cli.rs`'s own
`the_remote_knock_refusals_render_as_prose` — it RENDERS each refusal line and asserts no `"  "`,
with a planted run proving the predicate can fail. ⚠ But its site list is HAND-TYPED, so a new
variant is not covered until someone adds it: see
[[an-exhaustive-match-pins-placement-not-walk-list-membership]]. My new `KNOCK_PEER_SILENT` carried
exactly this defect AND was missing from that walk — the guard and the gap arrived together.