diff --git a/AGENTS.md b/AGENTS.md
index 4764b07..e8d5aaa 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,8 +11,9 @@
   wait for one.
 - README goal 3 is gated at 7.0 on the `comprehension-panel` skill, and below it
   nothing else merges — no feature, no category, no data — bar a security fix, a
-  dependency bump, a repair of behaviour the README documents, and the infrastructure
-  the round itself runs on. `todo.md` carries the round: a PR per item it plans, the nine-seat
+  dependency bump, a repair of behaviour the README documents, the infrastructure
+  the round itself runs on, and a chunk the comprehension-floor decision lists as
+  shipped under the floor. `todo.md` carries the round: a PR per item it plans, the nine-seat
   findings at depth 1 or a restructure the maintainer approved, then the nine-seat run
   again, until the score passes. At or above 7.0
   every pull request scores with the four-seat run and answers it in one run. No merge
@@ -38,10 +39,10 @@ In [docs/decisions.md](docs/decisions.md):
 - Options and fields share one namespace
 - `{a|b}` stays beside nested choices
 - Flags follow getopt_long
-- An argument is a template by its shape, not by a flag
-- The CLI renders the template on its stdin, less one newline ending it
-- An inline template that does not compile is misuse (exit 2), including a reference that resolves to nothing
-- A padded JSON argument is rejected, not trimmed
+- A struct tag is a template by its shape, not by a flag
+- The CLI renders the template on its stdin, keeping a format string's every byte
+- A template that does not compile is misuse (exit 2), including a reference that resolves to nothing, save the CLI's lone reference until item 129
+- A padded JSON template is rejected, not trimmed
 - `FakeTemplate` and `NewTemplate` both stay
 - The shipped data is embedded, not discovered
 - With only the shipped set, a category loads on the first call reaching it; beside a `--data-path`, every category loads in `New`
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8845a9a..3a28cb5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,10 +27,11 @@ replacement, and each removed path, column or flag.
   operand: `{/misc.coordinate.lat as lat}{calc(lat * 60)}`. What `New` refuses is listed
   under [Names](README.md#names).
 - First release: the CLI, the library and the shipped data set.
-- The CLI renders the template piped to its stdin, `echo -n '{/sv_SE.person} hihi' |
-  fejkdata`, and takes no path or template as an argument. One newline ending stdin,
-  `\n` or `\r\n`, is dropped. A template of one reference alone, `{/users}`, is the
-  record `users` under `--format`. An argument, or nothing piped in, exits 2.
+- The CLI renders the template on its stdin, `echo '{/sv_SE.person} hihi' | fejkdata`,
+  and takes no operand. A format string keeps every byte, `echo`'s newline included; a
+  JSON template or one reference alone drops one newline ending stdin, `\n` or `\r\n`.
+  One reference alone, `{/users}`, is the record `users` under `--format`. An operand,
+  or nothing piped in, exits 2.
 - Table categories: a category JSON naming a `rows` TSV beside it, with the options
   `key`, `name`, `weight` and `parent`; a path selects a row by key or name,
   `misc.territory[SE]`, and descends to a linked table by name, one path drawing each
diff --git a/README.md b/README.md
index 67c64de..72d5feb 100644
--- a/README.md
+++ b/README.md
@@ -6,41 +6,44 @@ reproducible.
 
 ```sh
 go install github.com/larvit/fejkdata/cmd/fejkdata@latest
-echo -n '{/sv_SE.person}' | fejkdata   # Sara Eriksson
+echo '{/sv_SE.person}' | fejkdata   # Sara Eriksson
 ```
 
 ## CLI
 
 ```sh
-echo -n '{/sv_SE.person}' | fejkdata                        # Sara Eriksson
-echo -n '{/sv_SE.person.last}' | fejkdata                   # Eriksson
-echo -n '{/sv_SE.person} hihi' | fejkdata                   # Sara Eriksson hihi
-echo -n '{/sv_SE.address}' | fejkdata --seed 42             # the same address every run
-echo -n '{/sv_SE.word}' | fejkdata -n 3 --separator ', '    # nät, barn, sol
-fejkdata --list                                             # every path the data offers
-echo -n '{/misc.territory[SE].capital}' | fejkdata          # Stockholm — a table's row, selected by key or name
-echo -n '{/geo.SE.locality[Lund].street}' | fejkdata        # Fjelievägen — a linked table, drawn inside the row
-echo -n '{/sv_SE.word}' | fejkdata --data-path ./mydata     # layer a directory over the shipped data
-fejkdata --no-shipped-data -d ./mydata --list               # only your data
-echo -n "{date(1990-01-01,2010-12-31,'2006-01-02')}" | fejkdata   # 2003-11-27 — the layout in '…'
-echo -n '{"format":"name: {x}","x":["bosse","lina"]}' | fejkdata  # name: bosse or name: lina
-fejkdata < template.txt                                     # a template kept in a file
+echo '{/sv_SE.person}' | fejkdata                       # Sara Eriksson
+echo '{/sv_SE.person.last}' | fejkdata                  # Eriksson
+echo '{/sv_SE.person} hihi' | fejkdata                  # Sara Eriksson hihi, then echo's newline
+echo '{/sv_SE.address}' | fejkdata --seed 42            # the same address every run
+echo '{/sv_SE.word}' | fejkdata -n 3 --separator ', '   # nät, barn, sol
+fejkdata --list                                         # every path the data offers
+echo '{/misc.territory[SE].capital}' | fejkdata         # Stockholm — a table's row, selected by key or name
+echo '{/geo.SE.locality[Lund].street}' | fejkdata       # Fjelievägen — a linked table, drawn inside the row
+echo '{/sv_SE.word}' | fejkdata --data-path ./mydata    # layer a directory over the shipped data
+fejkdata --no-shipped-data -d ./mydata --list           # only your data
+echo '{"format":"name: {x}","x":["bosse","lina"]}' | fejkdata   # name: bosse or name: lina
+fejkdata < template.txt                                 # a template kept in a file
+fejkdata <<'EOF'                                        # born 2003-11-27 — a quoted heredoc passes ', $ and \ as written
+born {date(1990-01-01,2010-12-31,'2006-01-02')}
+EOF
 ```
 
 fejkdata renders the template on its stdin: a format string, or a JSON object, array or
 string. Its `{…}` tokens reach the data by reference from the root,
 `{/sv_SE.person.last}`, so shipped and `--data-path` categories are alike available,
-and everything outside them prints as written. A reference names a category, or a field
+and everything outside them prints as written; stdin that is JSON is read as JSON, so
+`42`, `true` or `null` alone is refused. A reference names a category, or a field
 inside one: each dot segment descends one level — folders, then the category (a JSON
 file), then fields — and `[SE]` after a [table](#table) selects its row. `--list` prints
 these paths; a template reads one as `{/path}`.
 
-One newline ending stdin, `\n` or `\r\n`, is dropped, so `echo` and `echo -n`, a file
-and a heredoc render alike; end stdin with two newlines to print one. Some shells' `echo`
-reads a backslash as an escape, so pipe a template holding one with `printf '%s'` or from
-a file. One reference alone, `{/users}`, is the record `users` under `--format`; the
-rest of stdin's rules are under
-[Decisions](docs/decisions.md#the-cli-renders-the-template-on-its-stdin-less-one-newline-ending-it).
+A format string keeps every byte of stdin, so `echo`'s newline renders too; `printf '%s'`
+leaves it out. A JSON template or one reference alone drops one newline ending stdin,
+`\n` or `\r\n`, which neither could print. One reference alone, `{/users}`, is the record
+`users` under `--format`. Some shells' `echo` reads a backslash as an escape, so pipe a
+template holding one from a quoted heredoc or a file. The rest of stdin's rules are under
+[Decisions](docs/decisions.md#the-cli-renders-the-template-on-its-stdin-keeping-a-format-strings-every-byte).
 
 | Flag | |
 |------|--|
@@ -57,7 +60,7 @@ rest of stdin's rules are under
 `--name value` and `--name=value` both work, a short flag's value attaches or
 follows (`-n3`, `-n 3`) and short flags bundle (`-hn 3`) — see
 [Decisions](docs/decisions.md#flags-follow-getopt_long); flags go anywhere, `--` ends them. Exit codes: `0` success, `1` runtime error (missing
-dir, a lone reference to nothing), `2` misuse — a bad flag, an argument, nothing on stdin, or a
+dir, a lone reference to nothing), `2` misuse — a bad flag, an operand, nothing on stdin, or a
 template that does not compile. From a checkout:
 `go run ./cmd/fejkdata …`.
 
@@ -78,9 +81,9 @@ A category is a JSON file in a directory. Save this as `mydata/sql.json`:
 ```
 
 ```sh
-echo -n '{/sql}' | fejkdata --seed 1 --data-path ./mydata
+echo '{/sql}' | fejkdata --seed 1 --data-path ./mydata
 # INSERT INTO users VALUES('zoom'),('wahoo'),('blip');
-echo -n '{/sql}' | fejkdata --repeat 100 --data-path ./mydata > seed.sql
+echo '{/sql}' | fejkdata --repeat 100 --data-path ./mydata > seed.sql
 ```
 
 That `format` string is the free-form spelling — you hand-write the whole row.
@@ -103,11 +106,11 @@ the whole. `--format json|ndjson|csv|sql` writes the records; the library's
 ```
 
 ```sh
-echo -n '{/users}' | fejkdata --seed 1 -d ./mydata --format json               # [{"first":"Bo","last":"Lovelace"}]
-echo -n '{/users}' | fejkdata --seed 1 -d ./mydata --format ndjson             # {"first":"Bo","last":"Lovelace"}
-echo -n '{/users}' | fejkdata --seed 1 -d ./mydata --format csv                # first,last  →  Bo,Lovelace
-echo -n '{/users}' | fejkdata --seed 1 -d ./mydata --format sql                # INSERT INTO "users" ("first", "last") VALUES ('Bo', 'Lovelace');
-echo -n '{/users}' | fejkdata --seed 1 -d ./mydata --format sql --table people # INSERT into another table
+echo '{/users}' | fejkdata --seed 1 -d ./mydata --format json               # [{"first":"Bo","last":"Lovelace"}]
+echo '{/users}' | fejkdata --seed 1 -d ./mydata --format ndjson             # {"first":"Bo","last":"Lovelace"}
+echo '{/users}' | fejkdata --seed 1 -d ./mydata --format csv                # first,last  →  Bo,Lovelace
+echo '{/users}' | fejkdata --seed 1 -d ./mydata --format sql                # INSERT INTO "users" ("first", "last") VALUES ('Bo', 'Lovelace');
+echo '{/users}' | fejkdata --seed 1 -d ./mydata --format sql --table people # INSERT into another table
 ```
 
 A record is one reference alone, `{/users}`, or a template whose fields are its
@@ -508,11 +511,11 @@ SE	Sweden	10500000
 ```
 
 ```sh
-echo -n '{/country}' | fejkdata -d ./mydata                  # Sweden (SE), about half the time
-echo -n '{/country.alpha2}' | fejkdata -d ./mydata           # NO
-echo -n '{/country[SE]}' | fejkdata -d ./mydata              # Sweden (SE)
-echo -n '{/country[Norway].alpha2}' | fejkdata -d ./mydata   # NO
-echo -n '{/country}' | fejkdata -d ./mydata --format csv     # alpha2,name,population  →  SE,Sweden,10500000
+echo '{/country}' | fejkdata -d ./mydata                  # Sweden (SE), about half the time
+echo '{/country.alpha2}' | fejkdata -d ./mydata           # NO
+echo '{/country[SE]}' | fejkdata -d ./mydata              # Sweden (SE)
+echo '{/country[Norway].alpha2}' | fejkdata -d ./mydata   # NO
+echo '{/country}' | fejkdata -d ./mydata --format csv     # alpha2,name,population  →  SE,Sweden,10500000
 ```
 
 `rows` names the TSV beside the category file; `key` names the column a path
@@ -568,10 +571,10 @@ Stockholm	SE	990000
 ```
 
 ```sh
-echo -n '{/country[SE].city}' | fejkdata -d ./mydata    # Stockholm or Göteborg
-echo -n '{/country.city.name}' | fejkdata -d ./mydata   # a country drawn, then a city inside it
-echo -n '{/city[Oslo].country}' | fejkdata -d ./mydata  # NO — the link column's cell
-echo -n '{/city as c}{c.name}, {c..country.name}' | fejkdata -d ./mydata   # Oslo, Norway — one city and its country
+echo '{/country[SE].city}' | fejkdata -d ./mydata    # Stockholm or Göteborg
+echo '{/country.city.name}' | fejkdata -d ./mydata   # a country drawn, then a city inside it
+echo '{/city[Oslo].country}' | fejkdata -d ./mydata  # NO — the link column's cell
+echo '{/city as c}{c.name}, {c..country.name}' | fejkdata -d ./mydata   # Oslo, Norway — one city and its country
 ```
 
 A path descends from a row to a linked table by name, at any depth, and `--list`
@@ -593,10 +596,10 @@ chain of parents that closes, and a table named like a column of any table above
 after the `..`:
 
 ```sh
-echo -n '{/city[Oslo]..country.name}' | fejkdata -d ./mydata       # Norway
-echo -n '{/city..country}' | fejkdata -d ./mydata                  # a city drawn, then its country: Sweden (SE)
-echo -n '{/city[Göteborg]..country.city}' | fejkdata -d ./mydata   # Stockholm or Göteborg, drawn afresh
-echo -n '{/city as c}{c}, {c..country.name}' | fejkdata -d ./mydata  # Oslo, Norway
+echo '{/city[Oslo]..country.name}' | fejkdata -d ./mydata       # Norway
+echo '{/city..country}' | fejkdata -d ./mydata                  # a city drawn, then its country: Sweden (SE)
+echo '{/city[Göteborg]..country.city}' | fejkdata -d ./mydata   # Stockholm or Göteborg, drawn afresh
+echo '{/city as c}{c}, {c..country.name}' | fejkdata -d ./mydata  # Oslo, Norway
 ```
 
 It steps up from a selected row, a drawn row or a [name](#names) bound to a row, one
@@ -922,7 +925,7 @@ Where the project is heading; the sections before Audience document what ships t
       fails to load instead.
    2. Data that reads something nobody provided fails to load, and the error names the
       module that provides it by default, or says that none does.
-7. **One command gets you a value.**
+7. **One command line gets you a value.**
    1. Flags work like in other command-line tools, and can go anywhere on the line.
    2. Your first template of your own needs no escaping and no options.
    3. The CLI fills in what you leave out with a sane default: all the shipped data, the
diff --git a/cmd/fejkdata/main.go b/cmd/fejkdata/main.go
index 03b6c9b..1b5cd48 100644
--- a/cmd/fejkdata/main.go
+++ b/cmd/fejkdata/main.go
@@ -1,14 +1,15 @@
 // Command fejkdata renders the template on its stdin with fake values from the shipped
 // data and any directories layered over it.
 //
-//	echo -n '{/sv_SE.person}' | fejkdata                        # a full person
-//	echo -n 'name: {/sv_SE.person.last}' | fejkdata             # text around a surname
-//	echo -n '{/sv_SE.person}' | fejkdata --data-path ./mydata   # layer custom data; the last dir wins
-//	echo -n '{/sv_SE.address}' | fejkdata --seed 42
+//	echo '{/sv_SE.person}' | fejkdata                        # a full person
+//	echo 'name: {/sv_SE.person.last}' | fejkdata             # text around a surname
+//	echo '{/sv_SE.person}' | fejkdata --data-path ./mydata   # layer custom data; the last dir wins
+//	echo '{/sv_SE.address}' | fejkdata --seed 42
 package main
 
 import (
 	"bufio"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -22,21 +23,29 @@ import (
 )
 
 const usage = `Usage: <template> | fejkdata [flags]
+       fejkdata --list | --help | --version
 
 fejkdata reads one template from stdin and renders it:
 
-  echo -n 'name: {/sv_SE.person.last}' | fejkdata
-  echo -n '{"format":"{x}","x":["bosse","lina"]}' | fejkdata
+  echo 'name: {/sv_SE.person.last}' | fejkdata
+  echo '{"format":"{x}","x":["bosse","lina"]}' | fejkdata
+  fejkdata < template.txt
+  fejkdata <<'EOF'
+  born {date(1990-01-01,2010-12-31,'2006-01-02')}
+  EOF
 
 A template is a format string, or a JSON object, array or string. Its {…} tokens
 reach the data by reference from the root, {/sv_SE.person.last}, whether the data
-is shipped or layered with --data-path; everything outside them prints as written.
+is shipped or layered with --data-path; everything outside them prints as written,
+and stdin that is JSON is read as JSON, so 42, true or null alone is refused.
 A reference names a category or a dotted path into one ({/sv_SE.person.last}), a
 table's row by key or name ({/misc.territory[SE]}), and .. steps up from a row to
 the row it links to ({/geo.SE.locality..municipality.name}).
 
-One newline ending stdin, \n or \r\n, is dropped, so echo and echo -n render
-alike; end stdin with two to print one.
+A format string keeps every byte of stdin, so echo's newline renders too. JSON and a
+lone reference drop one newline ending stdin, \n or \r\n, which neither could print.
+A quoted heredoc, <<'EOF', passes a template holding $, a backslash or a quote as
+written.
 
 With --format json, ndjson, csv or sql the template must name a record — a
 template whose fields are its columns, or one reference alone, {/sv_SE.person} —
@@ -46,7 +55,7 @@ and the rows are written as one JSON array, one JSON object per line, one CSV ro
   -d, --data-path D      a data directory to layer over the shipped data (repeatable; last wins on a clash)
       --format F         output form: text (default), json, ndjson, csv or sql
   -h, --help             print this help, then exit
-      --list             list the paths the data offers, each read from the root, then exit
+      --list             list the paths the data offers, each one a reference's path, then exit
       --no-shipped-data  load only the --data-path directories
   -n, --repeat N         render the template N times, 1..1048576 (default 1)
   -s, --seed N           same seed, version and data: identical output
@@ -266,16 +275,28 @@ func (in invocation) checkFlags() error {
 	return nil
 }
 
-const pipeHint = "echo -n '{/sv_SE.person}' | fejkdata"
+const pipeHint = "echo '{/sv_SE.person}' | fejkdata"
 
-// check rejects a flag combination or an argument that cannot run, before any data is
+// operandError refuses an operand, naming the spelling that reads what it most likely
+// means: stdin for -, a file for a file's name, else the template piped in.
+func operandError(arg string) error {
+	if arg == "-" {
+		return errors.New("fejkdata takes no operand, and reads stdin already; drop the -")
+	}
+	if fi, err := os.Stat(arg); err == nil && fi.Mode().IsRegular() {
+		return fmt.Errorf("fejkdata takes no operand; read the file from stdin: fejkdata < %s", arg)
+	}
+	return fmt.Errorf("fejkdata takes no operand; pipe the template to stdin: %s", pipeHint)
+}
+
+// check rejects a flag combination or an operand that cannot run, before any data is
 // read.
 func (in invocation) check() error {
 	if err := in.checkFlags(); err != nil {
 		return err
 	}
 	if len(in.args) > 0 {
-		return fmt.Errorf("the template comes from stdin, not from an argument: %s", pipeHint)
+		return operandError(in.args[0])
 	}
 	if in.list && (in.repeatSet || in.separatorSet || in.formatSet || in.tableSet) {
 		return errors.New("--list takes no --repeat, --separator, --format or --table")
@@ -343,7 +364,7 @@ func (in invocation) recordStream(f *fejkdata.Generator, src input) (func() (*fe
 	if src.path == "" {
 		t, err := f.NewRecordTemplate(src.template)
 		if err != nil {
-			return nil, "", inputError{err}
+			return nil, "", inputError{spacedReference(src.template, err)}
 		}
 		record = func() (*fejkdata.Record, error) { return t.Fake(), nil }
 	}
@@ -410,9 +431,9 @@ func defaultTable(path string) string {
 	return segments[len(segments)-1]
 }
 
-// inputError marks a failure that is the input's own fault — no template, or one that
-// does not compile. run reports it as misuse (exit 2, with a pointer to --help), unlike
-// an unknown path, which is a runtime error (exit 1).
+// inputError marks a failure that is the input's own fault — no template, one that does
+// not compile, or a stdin that cannot be read. run reports it as misuse (exit 2, with a
+// pointer to --help), unlike a lone reference to nothing, which is a runtime error (exit 1).
 type inputError struct{ error }
 
 func (e inputError) Unwrap() error { return e.error }
@@ -423,37 +444,58 @@ type input struct {
 	template string
 }
 
-// parseInput reads stdin's text less one newline ending it.
+// parseInput reads stdin's text. A format string keeps every byte; JSON or a lone
+// reference sheds one newline ending it, which neither could print.
 func parseInput(raw string) (input, error) {
-	text, found := strings.CutSuffix(raw, "\n")
-	if found {
-		text = strings.TrimSuffix(text, "\r")
-	}
-	if text == "" {
+	if raw == "" {
 		return input{}, fmt.Errorf("stdin holds no template: %s", pipeHint)
 	}
-	if path, lone := loneReference(text); lone {
+	if text, found := strings.CutSuffix(raw, "\n"); found {
+		text = strings.TrimSuffix(text, "\r")
+		if path, lone := loneReference(text); lone {
+			return input{path: path}, nil
+		}
+		if json.Valid([]byte(text)) {
+			return input{template: text}, nil
+		}
+	}
+	if path, lone := loneReference(raw); lone {
 		return input{path: path}, nil
 	}
-	return input{template: text}, nil
+	return input{template: raw}, nil
 }
 
 // loneReference is the path that text, one reference from the root and nothing else,
-// reads: the path IsTemplate advises writing instead.
+// reads: the path IsTemplate advises writing instead. A JSON string holding one is one.
 func loneReference(text string) (string, bool) {
+	var unquoted string
+	if json.Unmarshal([]byte(text), &unquoted) == nil {
+		text = unquoted
+	}
 	if !strings.HasPrefix(text, "{/") || !strings.HasSuffix(text, "}") {
 		return "", false
 	}
 	if inline, err := fejkdata.IsTemplate(text); inline || err == nil {
 		return "", false
 	}
-	path := strings.TrimLeft(text[1:len(text)-1], "/")
+	path := text[2 : len(text)-1]
 	if inline, err := fejkdata.IsTemplate(path); inline || err != nil {
 		return "", false
 	}
 	return path, true
 }
 
+// spacedReference adds to err, a refusal of template as a record, that the whitespace
+// around a lone reference made it text, where it does.
+func spacedReference(template string, err error) error {
+	if trimmed := strings.TrimSpace(template); trimmed != template {
+		if path, lone := loneReference(trimmed); lone {
+			return fmt.Errorf("%w; the whitespace around {/%s} makes it text, so remove it to write the record %s", err, path, path)
+		}
+	}
+	return err
+}
+
 func main() {
 	var stdin io.Reader = os.Stdin
 	if fi, err := os.Stdin.Stat(); err == nil && fi.Mode()&os.ModeCharDevice != 0 {
@@ -512,7 +554,7 @@ func readStdin(stdin io.Reader) (input, error) {
 	}
 	raw, err := io.ReadAll(stdin)
 	if err != nil {
-		return input{}, err
+		return input{}, inputError{fmt.Errorf("stdin cannot be read: %w", err)}
 	}
 	src, err := parseInput(string(raw))
 	if err != nil {
diff --git a/cmd/fejkdata/main_test.go b/cmd/fejkdata/main_test.go
index 0767ca5..b6149ff 100644
--- a/cmd/fejkdata/main_test.go
+++ b/cmd/fejkdata/main_test.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/csv"
 	"encoding/json"
+	"errors"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -224,7 +225,6 @@ func TestRunMisuse(t *testing.T) {
 	}{
 		{"", nil},
 		{"", []string{"--data-path", svSE}},
-		{"\n", []string{"--data-path", svSE}},
 		{"{/person}", []string{"-d", svSE, "word"}},
 		{"", []string{"-d", svSE, "--list", "person"}},
 		{"{/sv_SE.person}", []string{"--no-shipped-data"}},
@@ -242,17 +242,39 @@ func TestRunMisuse(t *testing.T) {
 	}
 }
 
-// TestRunTakesNoArgument pins the error for a path or a template given as an argument:
-// it shows the template piped to stdin.
-func TestRunTakesNoArgument(t *testing.T) {
-	for _, args := range [][]string{{"sv_SE.person"}, {"{/sv_SE.person}"}, {"name:", "{/sv_SE.person.last}"}} {
-		code, out, errb := runOut("", args...)
-		if code != 2 || out != "" || !strings.Contains(errb, "stdin") || !strings.Contains(errb, "| fejkdata") {
-			t.Errorf("run(%v) = %d, %q, %q; want misuse showing a template piped to fejkdata", args, code, out, errb)
+func TestRunTakesNoOperand(t *testing.T) {
+	file := filepath.Join(t.TempDir(), "users.tmpl")
+	if err := os.WriteFile(file, []byte("{/sv_SE.person}"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	for _, c := range []struct {
+		args []string
+		want string
+	}{
+		{[]string{"sv_SE.person"}, "echo '{/sv_SE.person}' | fejkdata"},
+		{[]string{"{/sv_SE.person}"}, "echo '{/sv_SE.person}' | fejkdata"},
+		{[]string{"name:", "{/sv_SE.person.last}"}, "echo '{/sv_SE.person}' | fejkdata"},
+		{[]string{"-"}, "drop the -"},
+		{[]string{file}, "fejkdata < " + file},
+	} {
+		code, out, errb := runOut("", c.args...)
+		if code != 2 || out != "" || !strings.Contains(errb, "takes no operand") || !strings.Contains(errb, c.want) {
+			t.Errorf("run(%v) = %d, %q, %q; want misuse naming %q", c.args, code, out, errb, c.want)
 		}
 	}
 }
 
+type failingReader struct{}
+
+func (failingReader) Read([]byte) (int, error) { return 0, errors.New("bad file descriptor") }
+
+func TestRunUnreadableStdinIsMisuse(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := run(nil, failingReader{}, &out, &errb); code != 2 || !strings.Contains(errb.String(), "cannot be read") {
+		t.Errorf("run with an unreadable stdin = %d, %q; want misuse naming it", code, errb.String())
+	}
+}
+
 func TestRunTerminalStdinIsMisuse(t *testing.T) {
 	code, out, errb := runTerminal("--seed", "1")
 	if code != 2 || out != "" || !strings.Contains(errb, "| fejkdata") {
@@ -265,26 +287,26 @@ func TestRunTerminalStdinIsMisuse(t *testing.T) {
 	}
 }
 
-func TestRunDropsOneTrailingNewline(t *testing.T) {
+func TestRunNewlineEndingStdin(t *testing.T) {
 	for stdin, want := range map[string]string{
-		"hihi":         "hihi\n",
-		"hihi\n":       "hihi\n",
-		"hihi\r\n":     "hihi\n",
-		"hihi\n\n":     "hihi\n\n",
-		"hihi\r\n\r\n": "hihi\r\n\n",
-		"a\nb\n":       "a\nb\n",
-		" hihi \n":     " hihi \n",
-		"{{x}}\n":      "{x}\n",
-		"\"a\"\n":      "a\n",
+		"hihi":                             "hihi\n",
+		"hihi\n":                           "hihi\n\n",
+		"hihi\r\n":                         "hihi\r\n\n",
+		"\n":                               "\n\n",
+		"{{x}}\n":                          "{x}\n\n",
+		"\"a\"\n":                          "a\n",
+		"\"a\"\r\n":                        "a\n",
+		"{/misc.territory[SE].alpha2}\n":   "SE\n",
+		"{/misc.territory[SE].alpha2}\r\n": "SE\n",
 	} {
 		code, out, errb := runOut(stdin, "--seed", "1")
 		if code != 0 || out != want {
 			t.Errorf("run(%q) = %d, %q, %q; want %q", stdin, code, out, errb, want)
 		}
 	}
-	code, out, errb := runOut("x: {/sv_SE.person.last}\n\n", "--seed", "1")
+	code, out, errb := runOut("x: {/sv_SE.person.last}\n", "--seed", "1")
 	if code != 0 || !strings.HasPrefix(out, "x: ") || !strings.HasSuffix(out, "\n\n") || strings.Count(out, "\n") != 2 {
-		t.Errorf("a template ending in a newline = %d, %q, %q; want its own newline, then the line's", code, out, errb)
+		t.Errorf("echo's format string = %d, %q, %q; want echo's newline, then the line's", code, out, errb)
 	}
 }
 
@@ -413,10 +435,10 @@ func TestUsageReferencesResolve(t *testing.T) {
 	}
 }
 
-func TestRunArgumentMisuseBeforeLoad(t *testing.T) {
+func TestRunOperandMisuseBeforeLoad(t *testing.T) {
 	code, _, errb := runOut("", "--no-shipped-data", "x")
-	if code != 2 || !strings.Contains(errb, "stdin") || strings.Contains(errb, "--data-path") {
-		t.Fatalf("an argument with no data = %d, %q; want the argument refused before any load", code, errb)
+	if code != 2 || !strings.Contains(errb, "takes no operand") || strings.Contains(errb, "--data-path") {
+		t.Fatalf("an operand with no data = %d, %q; want the operand refused before any load", code, errb)
 	}
 }
 
@@ -452,6 +474,7 @@ func TestRunTemplateMisuse(t *testing.T) {
 		" [\"a\",\"b\"]":        "may not be padded",
 		"[\"a\",\"b\"]\n\n":     "may not be padded",
 		"42":                    "number",
+		"{//sv_SE.person}":      "write {/sv_SE.person}",
 	} {
 		code, out, errb := runOut(stdin, "--seed", "1")
 		if code != 2 || out != "" || !strings.Contains(errb, "try 'fejkdata --help'") || !strings.Contains(errb, want) {
@@ -605,6 +628,17 @@ func TestRunRecordDefaultTable(t *testing.T) {
 	}
 }
 
+func TestRunRecordOfAQuotedLoneReference(t *testing.T) {
+	code, out, errb := runOut(`"{/users}"`, "--seed", "1", "--format", "sql", "--data-path", recordDir(t))
+	if code != 0 || !strings.HasPrefix(out, `INSERT INTO "users" (`) {
+		t.Fatalf("a JSON string holding {/users} = %d, %q, %q; want the record users", code, out, errb)
+	}
+	code, out, errb = runOut("{/users} ", "--format", "csv", "--data-path", recordDir(t))
+	if code != 2 || out != "" || !strings.Contains(errb, "whitespace around {/users}") {
+		t.Errorf("{/users} and a space = %d, %q, %q; want misuse naming the whitespace", code, out, errb)
+	}
+}
+
 func TestRunRecordInlineTemplate(t *testing.T) {
 	code, out, errb := runOut(`{"format":"{x}","x":["a","b"]}`, "--seed", "1", "--format", "json")
 	if code != 0 {
diff --git a/docs/decisions.md b/docs/decisions.md
index e512aeb..86edde1 100644
--- a/docs/decisions.md
+++ b/docs/decisions.md
@@ -55,41 +55,43 @@ single-dash long flag is rejected naming the double-dash spelling, and `-s=42` i
 rejected naming both short spellings: `=` belongs to the long form, and reading `=42` as
 the value would make `-d=./x` a directory named `=./x`.
 
-## An argument is a template by its shape, not by a flag
+## A struct tag is a template by its shape, not by a flag
 
 2026-09-03, Lilleman auf Larv.
 
 A JSON object, array or string, or a string carrying a `{` token, is an inline template;
 anything else is a path. A name may not contain a brace, a bracket or a quote, so a path
 can never collide with any of those spellings, and the leading `[` or `"` is gated on
-valid JSON so a stray copied bracket never swallows an argument — it names nothing, and
-says so. No `--template` flag is needed. Reserving the characters whole — though only a
-leading one could collide — keeps one simple name rule instead of a leading-position
-special case. The JSON string is what makes the library's own advice reachable: the
-error for an object holding only a format names `"…"`, and that spelling has to work
-where it is printed. A struct tag of one reference alone, `{/users}`, is refused naming
-the path `users`: both render the same text, and only the path names a record. A folder-relative `{.name}` or `{..name}` is refused naming `{/name}`, since an
-inline template sits in no folder. `IsTemplate` exports the rule, so struct tags and any
-other caller read one.
+valid JSON so a stray copied bracket never swallows a tag — it names nothing, and says
+so. No option is needed. Reserving the characters whole — though only a leading one
+could collide — keeps one simple name rule instead of a leading-position special case.
+The JSON string is what makes the library's own advice reachable: the error for an
+object holding only a format names `"…"`, and that spelling has to work where it is
+printed. A struct tag of one reference alone, `{/users}`, is refused naming the path
+`users`: both render the same text, and only the path names a record. A folder-relative
+`{.name}` or `{..name}` is refused naming `{/name}`, since an inline template sits in no
+folder. `IsTemplate` exports the rule, so struct tags and any other caller read one.
 
-## The CLI renders the template on its stdin, less one newline ending it
+## The CLI renders the template on its stdin, keeping a format string's every byte
 
-2026-10-07, Lilleman auf Larv. Serves goals 7 and 7.2.
+2026-10-07, Lilleman auf Larv. Serves goals 7, 7.1 and 7.2.
 
-The CLI takes no path or template as an argument: an argument is misuse, and so is a
-terminal with nothing piped in, which would otherwise wait for typed input. Both errors
-show `echo -n '{/sv_SE.person}' | fejkdata`. One newline ending stdin, `\n` or `\r\n`,
-is dropped, so `echo`, a file and a heredoc render as `echo -n` does; only one, so a
-template that should end in a newline ends stdin with two. The rest of stdin reaches
-`NewTemplate` unchanged, so a padded JSON template is refused there, as goal 5.7 asks.
-One reference from the root and nothing else, `{/users}`, reads the path it names: it
+The template comes from stdin, from `echo`, a file or a heredoc, so one command line gets
+a value and a quoted heredoc needs no escape. The CLI takes no operand: one is misuse
+naming the spelling that reads what it likely means, `fejkdata < FILE` for a file and
+nothing for `-`, and so is a terminal with nothing piped in, which would otherwise wait
+for typed input. A format string keeps every byte, `echo`'s newline included, since
+everything outside `{…}` prints as written. JSON and one reference alone drop one newline
+ending stdin, `\n` or `\r\n`, which neither could print; the rest reaches `NewTemplate`
+unchanged, so a padded JSON template is refused there, as goal 5.7 asks. One reference
+from the root and nothing else, `{/users}` or `"{/users}"`, reads the path it names: it
 renders the same text, and under `--format` it is the record `users`, with `users` the
 default `--table`; one to nothing exits 1, as an unknown path does. That reading sits in
 the CLI against goal 3.2 until `todo.md` item 129 moves it into the library. `--list`
 still prints paths, each read as `{/path}`. Valid while the CLI reads one template per
 run.
 
-## An inline template that does not compile is misuse (exit 2), including a reference that resolves to nothing
+## A template that does not compile is misuse (exit 2), including a reference that resolves to nothing, save the CLI's lone reference until item 129
 
 2026-09-24, Lilleman auf Larv.
 
@@ -97,9 +99,9 @@ The whole template is the spelling under test, and `NewTemplate` compiles, links
 validates as one step. An unknown *path* stays a runtime error (exit 1): there the
 template is well-formed and only the data is absent.
 
-## A padded JSON argument is rejected, not trimmed
+## A padded JSON template is rejected, not trimmed
 
-2026-09-03, Lilleman auf Larv.
+2026-09-03, Lilleman auf Larv. Serves goal 5.7.
 
 Padding is the one place the two readings disagree — a format string renders it, JSON
 drops it — so the spelling that renders is named rather than silently chosen.
diff --git a/todo.md b/todo.md
index a38d812..0d2eb4e 100644
--- a/todo.md
+++ b/todo.md
@@ -6,7 +6,7 @@
 
 `Bar = 9`
 
-`Next ID = 157`
+`Next ID = 160`
 
 | Goal | W |
 |---|---|
@@ -74,6 +74,7 @@
 | 57 | 0.1.0 |  | **Rewrite `CHANGELOG.md`'s `[Unreleased]` as what v0.1.0 holds.** | 1 | 2 | 6 | 6 | 1.1 | 22.5 |
 | 96 | 0.1.0 |  | **Refuse two reads into one sibling, category or struct category that no name joins, `{place.postal-code} {place.locality}`, showing the spelling for one pick and the one for two.** | 4 | 4 | 7 | 7 | 5.6, 4 | 20.9 |
 | 153 | 0.1.0 | decision | **Run the nine-seat comprehension panel and the scoring run again once items 145 to 152 and item 10 have merged, and file what the panel names.** | 1 | 3 | 3 | 9 | 3 | 20.4 |
+| 157 | 0.1.0 |  | **Show in the README's CLI section how PowerShell and cmd.exe pipe a template, one line per shell family.** | 1 | 1 | 5 | 6 | 7.2 | 17.1 |
 | 89 | 0.1.0 |  | **Fail `New` without `WithSeed`, naming the option, and seed the CLI from the system.** | 3 | 3 | 6 | 7 | 10.1 | 16.0 |
 | 145 | 0.1.0 |  | **Move `doc.go`'s definitions of a level, a pick key and an addressed key, with their worked example, to `pickKey` in `pick.go`, and gather `levelKeys`, `addressedKeys`, `renderEnv.keeps` and `readField`'s kept read beside `readUnder`, so a reader follows a named read in one file.** | 2 | 3 | 1 | 9 | 3.4, 3.2 | 15.4 |
 | 127 | 0.1.0 |  | **Give a Swedish street only postal codes whose delivery digit means street or rural delivery, dropping codes whose delivery digit is 9, or record why they stay.** | 3 | 3 | 4 | 6 | 4 | 14.4 |
@@ -116,8 +117,10 @@
 | 42 | 0.2.0 |  | **Refuse a struct tag's `datatype` naming the Go type that sets it before proving its values, as the README's Library section promises.** | 2 | 2 | 4 | 6 | 6 | 14.5 |
 | 32 | 0.2.0 |  | **Add `misc.browser` as the parent of `misc.useragent`, so `misc.browser[Chrome].useragent` resolves.** | 3 | 3 | 4 | 6 | 4.1 | 14.4 |
 | 27 | 0.2.0 |  | **Merge `en_US.ip` and `sv_SE.ip`, today byte-identical, into one `misc.ip`.** | 3 | 2 | 4 | 6 | 5.7 | 14.1 |
+| 159 | 0.2.0 |  | **Name the quoted spelling where a template that is a bare JSON number, boolean or null is refused: `42` names `"42"`.** | 1 | 2 | 3 | 6 | 6, 5.1 | 14.1 |
 | 22 | 0.2.0 |  | **Give `url` and `email` a path that draws only domains nobody can register, keeping the wide set as the default.** | 3 | 4 | 7 | 8 | 16 | 14.0 |
 | 46 | 0.2.0 |  | **Report the same error every load for a table with two bad options, and for a folder with two unnamed rows files.** | 2 | 2 | 3 | 7 | 6, 10 | 14.0 |
+| 158 | 0.2.0 |  | **Drop a UTF-8 byte order mark that starts stdin, and say in the README how PowerShell 5.1 keeps `Göteborg` from reaching the CLI as `G?teborg`.** | 2 | 2 | 4 | 5 | 7.2, 5.1 | 13.5 |
 | 79 | 0.2.0 | decision | **Beside a `--data-path`, load in `New` the user's categories, the shipped ones they override or read, and the shipped ones whose reads reach an overridden one; load the rest on first reach.** | 6 | 6 | 7 | 8 | 13 | 12.9 |
 | 107 | 0.2.0 | decision | **Move the template engine into `internal/`, leaving the root the public API and its options.** | 6 | 9 | 3 | 8 | 3.2, 3.4 | 12.2 |
 | 112 | 0.2.0 |  | **Check a calc's field operands where its template resolves, beside its name operands, once item 36 reports every mistake at once.** | 2 | 2 | 1 | 6 | 3.2 | 10.3 |
@@ -251,8 +254,8 @@ Goal 5.9. Today a path is a second spelling of the template that reads it; after
 - Text that is not a JSON value and holds no `{…}` prints as written (goal 5.1), in a string field's struct tag and `Fake` alike, as stdin's text does in the CLI: `Fake("sv_SE.person")` returns `sv_SE.person`. `CHANGELOG.md` says that a path with no `{…}` prints as its text. A struct tag's `-` still skips its field.
 - Where text with no `{…}` is refused, as a record or in a typed struct field, and it spells a path the data offers, the error names `{/that.path}`.
 - An unknown reference exits 2, where an unknown path exits 1 today.
-- The README's CLI section gives one line per shell family, PowerShell and cmd.exe included, showing how to quote a template.
-- This revises the decisions "An argument is a template by its shape, not by a flag", "`FakeTemplate` and `NewTemplate` both stay", "`--list` stays a plain list of paths", and the exit-1 rule for an unknown path in "An inline template that does not compile is misuse (exit 2), including a reference that resolves to nothing". The README's examples and exit codes, the godoc examples in `doc.go`, the CLI's usage text and header comment, and `CHANGELOG.md`'s entries move to the template spelling. Delete items 40 and 110, which this closes.
+- Decide whether a lone reference draws as its path draws today or as a template draws: under one seed, `{/sv_SE.person}` and `{/sv_SE.person} hihi` pick different people.
+- This revises the decisions "A struct tag is a template by its shape, not by a flag", "`FakeTemplate` and `NewTemplate` both stay", "`--list` stays a plain list of paths", "The CLI renders the template on its stdin, keeping a format string's every byte", and the exit-1 rule for an unknown path in "A template that does not compile is misuse (exit 2), including a reference that resolves to nothing, save the CLI's lone reference until item 129". The README's examples and exit codes, the godoc examples in `doc.go`, the CLI's usage text and header comment, and `CHANGELOG.md`'s entries move to the template spelling. Delete items 40 and 110, which this closes.
 
 Split it into items for the CLI, struct tags and the library before starting.
 
@@ -268,6 +271,10 @@ Asked of the maintainer by the product-owner pass of the chunk that made every `
 
 The decision "comprehension floor: every dimension and the overall at 7.0 or above" holds the scores this run is measured against.
 
+### 157. Show in the README's CLI section how PowerShell and cmd.exe pipe a template, one line per shell family.
+
+Split from item 129. cmd.exe's `echo` keeps its quotes and a trailing space, so `echo {/users} | fejkdata` sends `{/users} ` and stops naming the record.
+
 ### 89. Fail `New` without `WithSeed`, naming the option, and seed the CLI from the system.
 
 Goal 10.1 has the caller supply the seed, and today `New` without `WithSeed` seeds itself. This item ships in 0.1.0 beside item 77, so `New` breaks once before anyone depends on it. Mark `WithSeed` required in the Library section's options table. Its tests then stop swapping `randomBytes`, as `fejkdata_test.go` does today, which fails every `New` in the package while that test runs.
@@ -431,6 +438,10 @@ Require the path step to reach a sibling category.
 
 `datatype: boolean` over `{int(1,2)}` on an `int` field answers `prints an integer, not a boolean`.
 
+### 159. Name the quoted spelling where a template that is a bare JSON number, boolean or null is refused: `42` names `"42"`.
+
+On stdin `42` is refused as "a number" and `null` with advice to write `""`, which prints nothing; neither names the text the author meant. The goals audit of the stdin change found it.
+
 ### 22. Give `url` and `email` a path that draws only domains nobody can register, keeping the wide set as the default.
 
 17 of the 40 distinct ones shipped today sit on `.se`, `.nu`, `.io` and `.co`, which anyone may register, and only RFC 2606's `example.com`, `.net`, `.org`, `.test`, `.example`, `.invalid` and `.localhost` provably reach nothing.
@@ -439,6 +450,10 @@ Require the path step to reach a sibling category.
 
 `readTableOptions` in `table.go` and `walkDir` in `internal/datafiles` return on the first in Go's map order.
 
+### 158. Drop a UTF-8 byte order mark that starts stdin, and say in the README how PowerShell 5.1 keeps `Göteborg` from reaching the CLI as `G?teborg`.
+
+A file a Windows editor saves with a BOM prints an invisible U+FEFF first, and a JSON template with one is read as a format string. PowerShell 5.1 encodes what it pipes to a program by `$OutputEncoding`, ASCII by default. The maintainer chose 0.2.0 on 2026-10-07.
+
 ### 79. Beside a `--data-path`, load in `New` the user's categories, the shipped ones they override or read, and the shipped ones whose reads reach an overridden one; load the rest on first reach.
 
 Needs item 77, which makes an override fail unless it says it replaces.