diff --git a/shape-doctor.py b/shape-doctor.py
index 9518ef83..2358acef 100755
--- a/shape-doctor.py
+++ b/shape-doctor.py
@@ -222,6 +222,19 @@
 reader improvises around -- which is the house rule the rest of this standard
 is built on.
 
+AND THE NEXT IS THE COMMAND AND NOTHING ELSE (#277). The sentence saying why
+it is the fix -- "read its output in full", "then apply --at ...", "what
+`make bootstrap` runs" -- used to ride on the same line as `   # <comment>`,
+because a terminal shows both at once. `sh`, bash and `zsh -c` read that `#`
+as a comment. An INTERACTIVE zsh without `interactivecomments` -- zsh's
+default, and macOS's login shell, the one a person pastes into -- reads it as
+a word: the pasted line handed the comment to the command as arguments, ran
+whatever followed a `;` as a second command, and ran whatever sat in
+backticks, `make bootstrap` among them. So `next` and the `NEXT` line are the
+bare command, pasted whole, and the sentence is the row's `why`: a `WHY` line
+under `NEXT` in the table, `"why"` on every row of `--json` (null where there
+is none), and a line after `Remediation:` when the report cannot answer.
+
 AND ONLY A `FINDING` MOVES THE VERDICT. A row is `ok`, `note`, `FINDING`,
 `n/a` or -- the Triad row alone -- `advisory`, and `FINDING` means exactly
 "something ELSE asserts this" -- a
@@ -707,10 +720,22 @@ def quote_arg(value, platform: str | None = None, *,
 
 
 class Row:
-    """One line of the report: what was asked, the answer, and the exit."""
+    """One line of the report: what was asked, the answer, and the exit.
+
+    `next_command` IS A COMMAND, WHOLE, AND `why` IS WHAT IS SAID ABOUT IT
+    (#277). The two were one string, `<command>   # <why>`, and the `#` is a
+    comment only to a shell that reads it as one: pasted into an interactive
+    zsh it was a word, the comment's text became arguments, a `;` in it ran a
+    second command and a pair of backticks ran a third. So a builder hands
+    the sentence over as `why`, a keyword of its own, and `next_command`
+    holds only what a reader pastes. `why` is never folded back into the
+    command line: `report` prints it on a `WHY` line of its own and `as_dict`
+    as its own key.
+    """
 
     def __init__(self, check_id: str, label: str, status: str, reason: str,
-                 next_command: str | None = None, detail: dict | None = None):
+                 next_command: str | None = None, detail: dict | None = None,
+                 *, why: str | None = None):
         self.id = check_id
         self.label = label
         self.status = status
@@ -721,14 +746,18 @@ def __init__(self, check_id: str, label: str, status: str, reason: str,
         # ordinary job, flattening this repository's own typography, on the
         # literal words a caller wrote around those values.
         self.next_command = ascii_text(next_command) if next_command else None
+        #: The sentence that explains `next_command`, kept off its line.
+        self.why = ascii_text(why) if why else None
         #: Structured facts for `--json`, so a caller reads numbers rather
         #: than parsing the sentence a human is meant to read.
         self.detail = detail or {}
 
     def as_dict(self) -> dict:
+        # `why` ON EVERY ROW, null where there is none, so a caller reads a
+        # key rather than testing for its absence -- as `placement_plan` is.
         return {"id": self.id, "label": self.label, "status": self.status,
                 "reason": self.reason, "next": self.next_command,
-                "detail": self.detail}
+                "why": self.why, "detail": self.detail}
 
 
 class Check:
@@ -1192,7 +1221,7 @@ def run_validator(ctx: Context, script: Path, args: list[str],
     DOCTOR'S OWN IS NEVER PART OF IT (#306). `pythonpath` is the directory to
     put on it, and `validator_row` passes `validator_scripts`'s answer: given
     one, the child's `PYTHONPATH` is that directory ALONE, the way the printed
-    `PYTHONPATH=<dir> python3 ...` sets it; given none, the child has NO
+    `env PYTHONPATH=<dir> python3 ...` sets it; given none, the child has NO
     `PYTHONPATH`, and the variable is taken OUT of the copy of the doctor's
     environment this builds, not left in it. ONE PLACE DECIDES, and it is the
     `env` block below: it does not ask whether the script is a root's own copy
@@ -1350,14 +1379,22 @@ def validator_command(shape: Path, used: Path, own_copy: bool, args: list,
 
     SO THE TEMPLATE'S LINE SETS IT, in the reader's dialect, which is the
     same two this file already speaks (`quote_arg`, `copy_command`,
-    `scaffold_command`): `PYTHONPATH=<shape>/scripts python3 <template> ...`
-    for `sh`, and `$env:PYTHONPATH = '<shape>\scripts'; python <template> ...`
-    for PowerShell. Both are ONE directory, so this is a plain assignment and
-    not a list, and it is what the doctor's child was given: that directory
-    ALONE (#306). The child used to have it PREPENDED to whatever the
-    environment already held, which a printed line cannot do, because it
-    cannot see the reader's value -- so the run and the line named two
-    different `PYTHONPATH`s.
+    `scaffold_command`): `env PYTHONPATH=<shape>/scripts python3
+    <template> ...` for `sh`, and `$env:PYTHONPATH = '<shape>\scripts';
+    python <template> ...` for PowerShell. Both are ONE directory, so this is
+    a plain assignment and not a list, and it is what the doctor's child was
+    given: that directory ALONE (#306). The child used to have it PREPENDED
+    to whatever the environment already held, which a printed line cannot
+    do, because it cannot see the reader's value -- so the run and the line
+    named two different `PYTHONPATH`s.
+
+    `env`, NOT A BARE `NAME=value` PREFIX (#277). The prefix is syntax of
+    `sh`, bash and zsh, and of nothing else a person may be pasting into:
+    csh and tcsh read `PYTHONPATH=...` as the name of a command and say
+    `Command not found`, and fish before 3.1 refused it, by those shells'
+    own documentation (none of the three was run for this change). `env` is
+    a PROGRAM, so the same line runs in every one of them, for four
+    characters, and it still sets the variable for this one command only.
 
     ONLY `PYTHONPATH`, and not the rest of the child's environment.
     `PYTHONIOENCODING` and `PYTHONDONTWRITEBYTECODE` exist so the DOCTOR can
@@ -1369,8 +1406,8 @@ def validator_command(shape: Path, used: Path, own_copy: bool, args: list,
     `quote_arg`'s `always`: what follows `=` is a pipeline, so a bare
     `C:\shape\scripts` would be run as a command and not assigned as a
     string. THE ASSIGNMENT LASTS FOR THE POWERSHELL SESSION, not for the one
-    command, and it REPLACES any `PYTHONPATH` the reader had: `sh`'s prefix
-    applies to one command and leaves the reader's environment alone, and
+    command, and it REPLACES any `PYTHONPATH` the reader had: `env` applies
+    it to one command and leaves the reader's environment alone, and
     this does not. That is accepted: the issue and the plan for this change
     named this spelling, `$env:` is PowerShell's idiom, and the effect ends
     with the session (review N1 on #238).
@@ -1389,7 +1426,7 @@ def validator_command(shape: Path, used: Path, own_copy: bool, args: list,
     if target == "nt":
         return (f"$env:PYTHONPATH = {quote_arg(scripts, target, always=True)}; "
                 f"{command}")
-    return f"PYTHONPATH={quote_arg(scripts, target)} {command}"
+    return f"env PYTHONPATH={quote_arg(scripts, target)} {command}"
 
 
 def validator_row(ctx: Context, check_id: str, label: str, own: str,
@@ -1435,9 +1472,10 @@ def validator_row(ctx: Context, check_id: str, label: str, own: str,
                    "question cannot be asked",
                    f"{PYTHON} "
                    f"{quote_arg(ctx.shape / 'shape-doctor.py')} --root "
-                   f"{quote_arg(ctx.root)}   # from a complete checkout of "
-                   "the standard; this one is missing that file",
-                   {"validator": None})
+                   f"{quote_arg(ctx.root)}",
+                   {"validator": None},
+                   why="from a complete checkout of the standard; this one "
+                       "is missing that file")
     unnamable = pythonpath_unnamable(ctx.shape, own_copy)
     if unnamable is not None:
         return Row(check_id, label, FINDING, f"{which} was not run: "
@@ -1474,9 +1512,9 @@ def validator_row(ctx: Context, check_id: str, label: str, own: str,
             reason += ("; that copy is this checkout's, not the project's, "
                        "so nothing here is a statement about the project")
         command = validator_command(ctx.shape, used, own_copy, args)
-        return Row(check_id, label, FINDING, reason,
-                   f"{command}   # read its output in full, it shows where "
-                   "the validator stopped", detail)
+        return Row(check_id, label, FINDING, reason, command, detail,
+                   why="read its output in full, it shows where the "
+                       "validator stopped")
     verb = "refuses" if code >= 2 else "reports a finding"
     reason = f"{which} {verb} (exit {code})" + (f": {quoted}" if quoted else "")
     # A COMMAND THAT RUNS WHEN IT IS PASTED. This row used to print
@@ -1488,11 +1526,11 @@ def validator_row(ctx: Context, check_id: str, label: str, own: str,
     # copy the line carries the `PYTHONPATH` the doctor ran it under, or it
     # dies on an import and exits with a finding's code (#238); the root's own
     # copy was run with no `PYTHONPATH` at all (#306), and its line carries
-    # none.
+    # none. AND IT IS ONLY THE COMMAND: what to do with its output is the
+    # row's `why`, on a line of its own (#277).
     command = validator_command(ctx.shape, used, own_copy, args)
-    return Row(check_id, label, FINDING, reason,
-               f"{command}   # read its output in full; it names what it "
-               "refused", detail)
+    return Row(check_id, label, FINDING, reason, command, detail,
+               why="read its output in full; it names what it refused")
 
 
 #: The row that OWNS each kind's manifest, by id: the one that quotes its
@@ -1578,7 +1616,8 @@ def unloaded_manifest_row(ctx: Context, check_id: str, label: str, own: str,
         missing = validator_row(ctx, check_id, label, own, template,
                                 ["--root", str(ctx.root)])
         return Row(check_id, label, FINDING, f"{reason}; {missing.reason}",
-                   missing.next_command, {**missing.detail, **detail})
+                   missing.next_command, {**missing.detail, **detail},
+                   why=missing.why)
     if own_copy and not imports_repo_shape(ctx.shape, used, own_copy):
         lost = repo_shape_for(ctx.shape, used, own_copy).relative_to(
             ctx.root).as_posix()
@@ -1592,13 +1631,13 @@ def unloaded_manifest_row(ctx: Context, check_id: str, label: str, own: str,
                        "name until it loads", None, detail)
         return Row(check_id, label, FINDING, reason,
                    f"git -C {quote_arg(ctx.root)} checkout HEAD -- "
-                   f"{quote_arg(lost)}   # it puts back the {lost} HEAD "
-                   f"holds, the copy this project committed and {own} "
-                   "imports, where update-shape.py apply would copy a newer "
-                   f"one, then run {own} again: it refuses {name} by name "
-                   "until it loads. "
-                   "A deletion already committed comes back from the parent "
-                   "of the commit that made it, not from HEAD", detail)
+                   f"{quote_arg(lost)}", detail,
+                   why=f"it puts back the {lost} HEAD holds, the copy this "
+                       f"project committed and {own} imports, where "
+                       "update-shape.py apply would copy a newer one, then "
+                       f"run {own} again: it refuses {name} by name until it "
+                       "loads. A deletion already committed comes back from "
+                       "the parent of the commit that made it, not from HEAD")
     unnamable = pythonpath_unnamable(ctx.shape, own_copy)
     if unnamable is not None:
         return Row(check_id, label, FINDING,
@@ -1606,13 +1645,12 @@ def unloaded_manifest_row(ctx: Context, check_id: str, label: str, own: str,
                    f"here: {unnamable}", None, detail)
     command = validator_command(ctx.shape, used, own_copy,
                                 ["--root", ctx.root])
-    return Row(check_id, label, FINDING, reason,
-               f"{command}   "
-               f"# the file to fix is {quote_arg(ctx.manifest_path)}, where "
-               "the line above says; this refuses it the same way until it "
-               "loads. What it should say there -- a merge conflict "
-               "resolved, a hand edit put right -- is the person's call",
-               detail)
+    return Row(check_id, label, FINDING, reason, command, detail,
+               why=f"the file to fix is {quote_arg(ctx.manifest_path)}, "
+                   "where the line above says; this refuses it the same way "
+                   "until it loads. What it should say there -- a merge "
+                   "conflict resolved, a hand edit put right -- is the "
+                   "person's call")
 
 
 def waiting_row(ctx: Context, check_id: str, label: str, needs: str,
@@ -2361,12 +2399,12 @@ def check_manifest_kinds(ctx: Context) -> Row:
         if beside is not None:
             parts.append(beside[0])
             fixes.append(FAMILY_BESIDE_FIX)
-        command = "; ".join(fixes)
+        command, why = "; ".join(fixes), None
         if unreadable:
-            restore, command = unreadable_next(ctx, unreadable, detail)
+            restore, command, why = unreadable_next(ctx, unreadable, detail)
             detail.update({"restore": restore, "refusals": refusals})
         return Row("manifest-kinds", LABEL_MANIFEST_KINDS, FINDING,
-                   "; ".join(parts) + aside, command, detail)
+                   "; ".join(parts) + aside, command, detail, why=why)
     return Row("manifest-kinds", LABEL_MANIFEST_KINDS, OK,
                f"{len(known)} manifest(s), every declared kind has a "
                f"registered validator{aside}", None, detail)
@@ -2515,7 +2553,7 @@ def pin_at(ctx: Context, rev: str, pin: str = SHAPE_PIN):
     THE ROWS, NOT A YES, for the shape pin (review of PR #358): `rev` may
     be an index stage, `:2` or `:3`, and the rows of the side of a merge
     `pin_restore` takes whole are the copies that side's tool wrote, so
-    they are the conflicted files its note gives a person to merge (#485).
+    they are the conflicted files its `why` gives a person to merge (#485).
     """
     blob = git_answer(["cat-file", "blob", f"{rev}:./{pin}"],
                       ctx.root, binary=True)
@@ -2534,9 +2572,11 @@ def pin_at(ctx: Context, rev: str, pin: str = SHAPE_PIN):
 
 
 def pin_restore(ctx: Context, detail: dict | None = None,
-                pin: str = SHAPE_PIN) -> tuple[str, str | None]:
-    """`(restore, command)`: the git command that puts back a pin a tool
-    wrote, chosen from the pin's own git state, read-only (#237).
+                pin: str = SHAPE_PIN) -> tuple[str, str | None, str | None]:
+    """`(restore, command, why)`: the git command that puts back a pin a tool
+    wrote, chosen from the pin's own git state, read-only (#237), and the
+    sentence that says what it does -- the row's `why`, apart from the
+    command and never a `   # ` tail on it (#277).
 
     A PIN IS NEVER MENDED BY HAND, so the fix for one that does not read is
     the last one a tool wrote, out of the root's own history. Which command
@@ -2558,7 +2598,7 @@ def pin_restore(ctx: Context, detail: dict | None = None,
                    and not this standard's copy lists, since a file the pin
                    has no row for is not a shape copy, though the lists
                    name its path (review of PR #358). Where one of them is
-                   conflicted the note says a person merges it by hand,
+                   conflicted the `why` says a person merges it by hand,
                    keeping the hunks git merged, as a copy conflicted on its
                    own is merged, and that `update-shape.py apply
                    --accept-local` on a copy merged unlike the pin re-pins
@@ -2576,9 +2616,9 @@ def pin_restore(ctx: Context, detail: dict | None = None,
                    `apply` writes lines of them: every other line is the
                    project's own, and one side taken whole drops the other
                    side's edits, the hunks git merged cleanly included
-                   (review of PR #267). Where either is conflicted the note
+                   (review of PR #267). Where either is conflicted the `why`
                    says a person merges it.
-                   `detail["left_for_a_person"]` lists every file the note
+                   `detail["left_for_a_person"]` lists every file the `why`
                    gives a person. A file of the project's own is never
                    named: its merge is theirs.
       uncommitted  HEAD holds a pin that reads, and the tree or the index
@@ -2598,7 +2638,8 @@ def pin_restore(ctx: Context, detail: dict | None = None,
       none         nothing above: no history, a root commit, no git, a walk
                    that meets a parent holding no pin, or goes
                    `PIN_HISTORY_DEPTH` commits back, before a pin that reads.
-                   Nothing git can name fixes it, and the caller says so.
+                   Nothing git can name fixes it, and the caller says so:
+                   `(restore, None, None)`.
 
     EVERY PIN THE COMMAND PUTS BACK IS READ FIRST, by `pin_reads_at`, except
     the side of a merge, which is one tool's output either way.
@@ -2616,8 +2657,8 @@ def pin_restore(ctx: Context, detail: dict | None = None,
     names another file `tool_written` admits -- a pin `project.yaml`
     declares, for a leg or a neutral product, or a copy the shape pin has a
     row for -- which is how the `manifest kinds` row answers each one that
-    does not load. The note says `copy` where the file is not a pin, and
-    `pin_reads_at` says what reads. Only the shape pin's note names other
+    does not load. The `why` says `copy` where the file is not a pin, and
+    `pin_reads_at` says what reads. Only the shape pin's `why` names other
     paths of a merge, for a person to merge by hand: the copies `apply`
     writes in the same commit, and a conflicted manifest or README.md.
     Every pin is named alone. A leg pin moves with its gitlink, but
@@ -2646,15 +2687,17 @@ def pin_restore(ctx: Context, detail: dict | None = None,
     git_c = f"git -C {quote_arg(root)}"
     what = "pin" if pin.endswith("-pin.yaml") else "copy"
     shown = edited_by_hand(ctx, pin)
-    why = BY_HAND_WHY[what]
+    # Part of the `why` where the file is `shown`, and not the `why` itself.
+    by_hand = BY_HAND_WHY[what]
     raw = git_answer(["--no-optional-locks", "status", "--porcelain=v1",
                       "--", pin], root, binary=True)
     xy = raw.decode("utf-8", "replace")[:2] if raw else ""
     if xy in UNMERGED_STATUS and shown:
         return "unmerged", (
-            f"{git_c} diff -- {quote_arg(pin)}   # a merge left the {what} "
-            "conflicted, and this shows the hunks git could not merge. "
-            f"{why}, so neither side is taken whole: merge it by hand, "
+            f"{git_c} diff -- {quote_arg(pin)}"
+        ), (f"a merge left the {what} conflicted, and this shows the hunks "
+            "git could not merge. "
+            f"{by_hand}, so neither side is taken whole: merge it by hand, "
             "keeping the hunks git merged, then finish the merge as git says "
             "and run this doctor again")
     if xy in UNMERGED_STATUS:
@@ -2717,32 +2760,34 @@ def pin_restore(ctx: Context, detail: dict | None = None,
                              "for --accept-local on that path")
                 then = ". " + ". ".join(said) + ". Then finish"
             return "unmerged", (
-                f"{git_c} checkout {side} -- {quote_arg(pin)}   # {note} and "
-                f"never a hand-merged {what}{then} the merge as git says and "
-                f"run this doctor again{after}")
+                f"{git_c} checkout {side} -- {quote_arg(pin)}"
+            ), (f"{note} and never a hand-merged {what}{then} the merge as "
+                f"git says and run this doctor again{after}")
     elif pin_reads_at(ctx, "HEAD", pin):
         if xy and shown:
             return "uncommitted", (
-                f"{git_c} diff HEAD -- {quote_arg(pin)}   # HEAD holds a "
-                f"{what} that reads, and this shows the uncommitted change "
-                f"that breaks the {what} here. {why}. Git keeps no other copy "
-                "of the change until it is committed, so nothing is put back. "
-                f"Mend the change, or take the {what} as last committed once "
-                "nothing in it is worth keeping, then run this doctor again")
+                f"{git_c} diff HEAD -- {quote_arg(pin)}"
+            ), (f"HEAD holds a {what} that reads, and this shows the "
+                f"uncommitted change that breaks the {what} here. {by_hand}. "
+                "Git keeps no other copy of the change until it is "
+                "committed, so nothing is put back. Mend the change, or take "
+                f"the {what} as last committed once nothing in it is worth "
+                "keeping, then run this doctor again")
         if xy:
             return "uncommitted", (
-                f"{git_c} checkout HEAD -- {quote_arg(pin)}   # puts back "
-                f"the {what} as last committed and discards the uncommitted "
-                "change that broke it, which no tool of this standard writes")
+                f"{git_c} checkout HEAD -- {quote_arg(pin)}"
+            ), (f"puts back the {what} as last committed and discards the "
+                "uncommitted change that broke it, which no tool of this "
+                "standard writes")
         return "hidden", (
-            f"{git_c} ls-files -v -- {quote_arg(pin)}   # HEAD holds a "
-            f"{what} that reads and git status shows no change to the copy "
-            "here, so no commit broke it and nothing in history is put back. "
-            "S in the first column is skip-worktree, as a sparse checkout "
-            "sets it, and a lowercase h is assume-unchanged: either hides the "
-            "copy here from git. Any other letter means the file itself "
-            "cannot be read, as the refusal says. Clearing that is for a "
-            "person, then run this doctor again")
+            f"{git_c} ls-files -v -- {quote_arg(pin)}"
+        ), (f"HEAD holds a {what} that reads and git status shows no change "
+            "to the copy here, so no commit broke it and nothing in history "
+            "is put back. S in the first column is skip-worktree, as a sparse "
+            "checkout sets it, and a lowercase h is assume-unchanged: either "
+            "hides the copy here from git. Any other letter means the file "
+            "itself cannot be read, as the refusal says. Clearing that is for "
+            "a person, then run this doctor again")
     history = git_answer(["rev-list", "-n", str(PIN_HISTORY_DEPTH), "HEAD",
                           "--", pin], root)
     for breaking in (history or "").split():
@@ -2754,19 +2799,18 @@ def pin_restore(ctx: Context, detail: dict | None = None,
             continue
         if shown:
             return "committed", (
-                f"{git_c} diff {quote_arg(before)} -- {quote_arg(pin)}   # "
-                f"the newest {what} in its history that reads is the one "
+                f"{git_c} diff {quote_arg(before)} -- {quote_arg(pin)}"
+            ), (f"the newest {what} in its history that reads is the one "
                 f"before {breaking[:12]}, the commit that broke it, and this "
-                f"shows every change since. {why}, so nothing is rolled "
+                f"shows every change since. {by_hand}, so nothing is rolled "
                 f"back: mend the {what}, commit that and run this doctor "
                 "again")
         return "committed", (
-            f"{git_c} checkout {quote_arg(before)} -- "
-            f"{quote_arg(pin)}   # the {what} as it was before "
-            f"{breaking[:12]}, the commit that broke it, and the newest "
-            f"{what} in its history that reads. Commit that rather than "
-            f"editing the {what}")
-    return "none", None
+            f"{git_c} checkout {quote_arg(before)} -- {quote_arg(pin)}"
+        ), (f"the {what} as it was before {breaking[:12]}, the commit that "
+            f"broke it, and the newest {what} in its history that reads. "
+            f"Commit that rather than editing the {what}")
+    return "none", None, None
 
 
 def declared_pins(ctx: Context) -> set:
@@ -2837,7 +2881,8 @@ def edited_by_hand(ctx: Context, rel: str) -> bool:
 
 
 #: Why `pin_restore` puts nothing back for a file `edited_by_hand`, by what
-#: its note calls the file. No `;`, apostrophe or backtick (#277).
+#: its `why` calls the file: part of that `why`, off the command's line
+#: (#277).
 BY_HAND_WHY = {
     "copy": ("A copy can hold an edit of the project, such as the merge by "
              "hand update-shape.py asks for where a copy changed on both "
@@ -2881,9 +2926,9 @@ def tool_written(ctx: Context, rel: str) -> bool:
     return rel in declared_pins(ctx) or rel in pinned_copies(ctx)
 
 
-#: The note on the `manifest kinds` row's next command where no file that
-#: does not load has a copy git can put back (#291). No `;`, apostrophe or
-#: backtick, so a pasted line is one command in any shell (#277).
+#: The `why` of the `manifest kinds` row's next command where no file that
+#: does not load has a copy git can put back (#291): the row's `why`, off
+#: the command's line, so a pasted line is one command in any shell (#277).
 UNREADABLE_BY_HAND = (
     "the reason names each file that does not load and why, and none is a "
     "file this root declares a tool writes with a copy that reads in its "
@@ -2893,9 +2938,12 @@ def tool_written(ctx: Context, rel: str) -> bool:
 
 
 def unreadable_next(ctx: Context, unreadable: list,
-                    detail: dict | None = None) -> tuple[dict, str]:
-    """`(restore, command)` for the `manifest kinds` row's files that do not
-    load (#291): each file's case, and the one command the row prints.
+                    detail: dict | None = None
+                    ) -> tuple[dict, str, str | None]:
+    """`(restore, command, why)` for the `manifest kinds` row's files that
+    do not load (#291): each file's case, the one command the row prints,
+    and the sentence that goes with that command -- the row's `why`, apart
+    from it and never a `   # ` tail on it (#277).
 
     A FILE A TOOL WROTE IS PUT BACK FROM GIT by `pin_restore`. That is the
     helper the `shape currency` row uses for the shape pin, so both rows
@@ -2913,28 +2961,29 @@ def unreadable_next(ctx: Context, unreadable: list,
     merge, their uncommitted work, their last commit -- and nothing in this
     standard says which bytes are right. Where no file has a command to
     name, the command is this doctor again, to run once a person has mended
-    the file, and its note says that what the file should say is theirs to
+    the file, and its `why` says that what the file should say is theirs to
     decide. #205's `manifest` row answers a `project.yaml` that does not
-    load the same way: the gate that refuses it, and that note.
+    load the same way: the gate that refuses it, and that `why`.
 
     WHAT THE SHAPE PIN'S MERGE LEAVES TO A PERSON IS SAID HERE TOO (#485).
     While the shape pin does not read, no row says what is a copy, so a
     copy conflicted beside it is not `tool_written`. The side of the merge
-    `pin_restore` takes does say, and its note gives each such copy to a
+    `pin_restore` takes does say, and its `why` gives each such copy to a
     person. That copy's case is `unmerged`, the one it has once the pin
     reads, and not `project`, and `detail` gets the `left_for_a_person`
     the `shape currency` row's has, so both rows say the same of the same
     command.
     """
     restore: dict[str, str] = {}
-    commands: dict[str, str] = {}
+    #: `(command, why)` for each file with a command, in the row's order.
+    commands: dict[str, tuple[str, str | None]] = {}
     held: dict = {}
     for rel in unreadable:
         if tool_written(ctx, rel):
-            restore[rel], found = pin_restore(
+            restore[rel], found, why = pin_restore(
                 ctx, held if rel == SHAPE_PIN else None, pin=rel)
             if found:
-                commands[rel] = found
+                commands[rel] = (found, why)
         else:
             restore[rel] = "project"
     left = held.get("left_for_a_person", [])
@@ -2943,11 +2992,13 @@ def unreadable_next(ctx: Context, unreadable: list,
             restore[rel] = "unmerged"
     if left and detail is not None:
         detail["left_for_a_person"] = left
-    command = commands.get(SHAPE_PIN) or next(iter(commands.values()), None)
+    command, why = (commands.get(SHAPE_PIN)
+                    or next(iter(commands.values()), (None, None)))
     if command is None:
         command = (f"{PYTHON} {quote_arg(ctx.shape / 'shape-doctor.py')} "
-                   f"--root {quote_arg(ctx.root)}   # {UNREADABLE_BY_HAND}")
-    return restore, command
+                   f"--root {quote_arg(ctx.root)}")
+        why = UNREADABLE_BY_HAND
+    return restore, command, why
 
 
 def unreadable_pin_row(ctx: Context, exc: Refusal) -> Row:
@@ -2979,28 +3030,29 @@ def unreadable_pin_row(ctx: Context, exc: Refusal) -> Row:
     THE NEXT PUTS BACK THE PIN A TOOL WROTE, NEVER A FETCH. `pin_restore`
     names the git command from the pin's own state, and run as printed it
     ends at `COMPLIANT` or at a row that reads the pin, but for what its
-    note gives a person: a conflicted copy, manifest or README.md, or an index
+    `why` gives a person: a conflicted copy, manifest or README.md, or an index
     flag that hides the pin. Naming the tool that refused, `update-shape.py
     check`, was a dead end (review of PR #267): it reads the pin with the
     same `read_pin`, refuses it the same way, and its remediation is about
-    submodules, adoption or a hand edit, none of which fits. That command stays only where git can name nothing, and its note
-    says the rest is a person's call. Each note holds no `;`, apostrophe or
-    backtick, so a pasted line is one command in any shell (#277).
+    submodules, adoption or a hand edit, none of which fits. That command
+    stays only where git can name nothing, and its `why` says the rest is a
+    person's call. Every sentence is the row's `why`, off the command's line,
+    so a pasted line is one command in any shell (#277).
     """
     detail = {"error": exc.code, "pin": SHAPE_PIN,
               "refusal": {"code": exc.code, "detail": exc.detail}}
-    restore, command = pin_restore(ctx, detail)
+    restore, command, why = pin_restore(ctx, detail)
     detail["restore"] = restore
     if command is None:
         command = (f"{PYTHON} {quote_arg(ctx.shape / 'update-shape.py')} "
                    f"check --root {quote_arg(ctx.root)} --upstream "
-                   f"{quote_arg(ctx.shape)}   # no commit in this root holds "
-                   "a pin to put back, so whether it was ever scaffolded or "
-                   "adopted is for a person to decide")
+                   f"{quote_arg(ctx.shape)}")
+        why = ("no commit in this root holds a pin to put back, so whether "
+               "it was ever scaffolded or adopted is for a person to decide")
     return Row("shape-currency", LABEL_SHAPE_CURRENCY, FINDING,
                f"the copies cannot be compared, because {SHAPE_PIN} does not "
                f"read as a pin: REFUSED {exc.code}: {exc.detail}",
-               command, detail)
+               command, detail, why=why)
 
 
 def check_shape_currency(ctx: Context) -> Row:
@@ -3042,11 +3094,11 @@ def check_shape_currency(ctx: Context) -> Row:
         # evidence that our copy of the standard is short a commit.
         return Row("shape-currency", LABEL_SHAPE_CURRENCY, FINDING,
                    f"the copies cannot be compared: {exc.detail}",
-                   f"git -C {quote_arg(ctx.shape)} fetch --all   # this "
-                   "checkout of the standard does not carry the commit the "
-                   "pin names; fetch "
-                   "it, or run the doctor from a clone that has it",
-                   {"error": exc.code, "environment": True})
+                   f"git -C {quote_arg(ctx.shape)} fetch --all",
+                   {"error": exc.code, "environment": True},
+                   why="this checkout of the standard does not carry the "
+                       "commit the pin names; fetch it, or run the doctor "
+                       "from a clone that has it")
     try:
         added = [add for add in additions if not add.present]
         reported = list(rows) + added
@@ -3108,25 +3160,30 @@ def check_shape_currency(ctx: Context) -> Row:
                        f"{PYTHON} "
                        f"{quote_arg(ctx.shape / 'update-shape.py')} check "
                        f"--root {quote_arg(ctx.root)} --upstream "
-                       f"{quote_arg(ctx.shape)}   # then apply --at "
-                       f"{quote_arg(target)} --yes --branch "
-                       f"{quote_arg('shape/update-' + target[:12])}"
-                       f"{lane_trailer_command()}", detail)
+                       f"{quote_arg(ctx.shape)}", detail,
+                       why=f"then apply --at {quote_arg(target)} --yes "
+                           "--branch "
+                           f"{quote_arg('shape/update-' + target[:12])}"
+                           f"{lane_trailer_command()}")
         accept = "".join(f" --accept-local {quote_arg(row.path)}"
                          for row in rows
                          if row.state == us.LOCALLY_MODIFIED)
         named = ", ".join(row.path for row in moved[:4])
         if len(moved) > 4:
             named += f", and {len(moved) - 4} more"
+        # The `check` is the NEXT, and the `apply` that follows the human's
+        # yes is the row's `why`, `--accept-local` and the lane's trailer
+        # included (#111): it is the second of two acts, never pasted with
+        # the first, and the `   # ` that joined them is what #277 removed.
         return Row("shape-currency", LABEL_SHAPE_CURRENCY, FINDING,
                    f"{summary} ({where}): {named}{note}",
                    f"{PYTHON} "
                    f"{quote_arg(ctx.shape / 'update-shape.py')} check --root "
-                   f"{quote_arg(ctx.root)} --upstream {quote_arg(ctx.shape)}"
-                   f"   # then apply --at {quote_arg(target)} --yes{accept} "
-                   f"--branch {quote_arg('shape/update-' + target[:12])}"
-                   f"{lane_trailer_command()}",
-                   detail)
+                   f"{quote_arg(ctx.root)} --upstream {quote_arg(ctx.shape)}",
+                   detail,
+                   why=f"then apply --at {quote_arg(target)} --yes{accept} "
+                       f"--branch {quote_arg('shape/update-' + target[:12])}"
+                       f"{lane_trailer_command()}")
     finally:
         upstream.close()
 
@@ -3168,30 +3225,32 @@ def own_bootstrap(root: Path, make_target: bool = False) -> bool:
     return re.search(r"(?m)^bootstrap\s*:", makefile) is not None
 
 
-def lockstep_next(ctx: Context, gate: tuple, noun: str) -> str | None:
-    """The line for what NO checkout cures: the lockstep gate, built the way
-    the `pins` and `family` rows build their own (`PINS_GATE`, `FAMILY_GATE`
-    and the same `--root` argument), so the template's line carries the
-    `PYTHONPATH` it needs (#238). None when neither copy is readable: that
-    is a standard with a hole in it, the gate's own row says so in the same
-    report, and a command that cannot run is the defect #276 is about. None
-    too when no `PYTHONPATH` can name the template's `scripts/` (#278): the
-    gate's own row is then an environment row that says why, and a line that
-    splits when pasted is the same defect.
+def lockstep_next(ctx: Context, gate: tuple, noun: str) -> tuple:
+    """`(the line, why it is the line)` for what NO checkout cures: the
+    lockstep gate, built the way the `pins` and `family` rows build their
+    own (`PINS_GATE`, `FAMILY_GATE` and the same `--root` argument), so the
+    template's line carries the `PYTHONPATH` it needs (#238). `(None, None)`
+    when neither copy is readable: that is a standard with a hole in it, the
+    gate's own row says so in the same report, and a command that cannot run
+    is the defect #276 is about. `(None, None)` too when no `PYTHONPATH` can
+    name the template's `scripts/` (#278): the gate's own row is then an
+    environment row that says why, and a line that splits when pasted is the
+    same defect.
 
     The `legs` and `members` rows say the same thing about a leg and about a
-    member, so the sentence is written here once.
+    member, so the sentence is written here once -- and it is the row's
+    `why`, apart from the line, never a `   # ` tail on it (#277).
     """
     used, _, own_copy = validator_for(ctx, *gate)
     if (not used.is_file()
             or pythonpath_unnamable(ctx.shape, own_copy) is not None):
-        return None
+        return None, None
     command = validator_command(ctx.shape, used, own_copy,
                                 ["--root", str(ctx.root)])
-    return (f"{command}   # no submodule update cures a {noun} whose gitlink "
-            "or pin is missing or disagrees, or a mount git cannot read a "
-            f"HEAD in. {used.name} prints what it finds and names the repair "
-            "where it has one")
+    return command, (f"no submodule update cures a {noun} whose gitlink "
+                     "or pin is missing or disagrees, or a mount git cannot "
+                     f"read a HEAD in. {used.name} prints what it finds and "
+                     "names the repair where it has one")
 
 
 def submodule_update_next(root: Path, paths: list[str], off_pin: list[Path],
@@ -3237,10 +3296,11 @@ def submodule_update_next(root: Path, paths: list[str], off_pin: list[Path],
     learns to skip the sentence on the day it can.
 
     THE SENTENCE CARRIES NONE OF `;`, `'`, A BACKTICK OR A PARENTHESIS. It
-    is a `   # ` tail today and a tail is pasted with the line: a shell that
-    does not treat `#` as a comment reads each of those as syntax. It is
-    plain words, so that moving it out of the NEXT later (#277) is a move
-    and not a rewrite. `after` is the caller's own closing sentence, and
+    was written as a `   # ` tail, and a tail is pasted with the line: a
+    shell that does not treat `#` as a comment reads each of those as
+    syntax. It was plain words so that moving it out of the NEXT (#277)
+    would be a move and not a rewrite, and it was: it is the row's `why`,
+    on a line of its own. `after` is the caller's own closing sentence, and
     `rerun` adds the one the `legs` and `members` rows share: some other
     leg or member is something this line does not cure, and the next run
     names it.
@@ -3378,15 +3438,16 @@ def check_legs(ctx: Context) -> Row:
                 after = (". Then make bootstrap puts each leg on its "
                          "tracking branch, and leaves alone one whose branch "
                          "is already ahead of the pin")
-            line, why = submodule_update_next(ctx.root, checkout, off_pin,
-                                              "leg", after, bool(lockstep))
-            next_command = f"{line}   # {why}"
+            # The line is the NEXT and what it does is the row's `why`, on a
+            # line of its own (#277).
+            next_command, why = submodule_update_next(
+                ctx.root, checkout, off_pin, "leg", after, bool(lockstep))
         else:
             # NO CHECKOUT CURES IT: the lockstep gate, one definition of it
             # for this row and the `pins` row (`lockstep_next`).
-            next_command = lockstep_next(ctx, PINS_GATE, "leg")
+            next_command, why = lockstep_next(ctx, PINS_GATE, "leg")
         return Row("legs", "legs", FINDING, "; ".join(problems),
-                   next_command, detail)
+                   next_command, detail, why=why)
     return Row("legs", "legs", OK,
                f"{len(rows)} leg(s) mounted and checked out at their pins",
                None, detail)
@@ -3402,7 +3463,9 @@ def lane_trailer_command(platform: str | None = None) -> str:
     printed the apply without it handed somebody a command whose result they
     then had to amend by hand. Four InkRouter re-pins landed on 2026-09-11
     with no trailer at all, each one run exactly as the line printed it
-    (#111).
+    (#111). The `apply` it ends is the `shape currency` row's `why` since
+    #277 -- the words that used to follow `   # ` on its NEXT line -- and the
+    trailer went with it, unchanged.
 
     NOTHING WHEN NO LANE IS SET, which is what keeps every row this file has
     ever printed byte-identical for everybody who is not in a lane; and only
@@ -3554,8 +3617,8 @@ def leg_shape_summary(rel: str, entry: dict) -> str:
     return f"{rel}: {named}"
 
 
-def missing_shape_file_fix(ctx: Context, missing: list) -> str:
-    """The next command for a leg missing a shape file, or why there is none.
+def missing_shape_file_fix(ctx: Context, missing: list) -> tuple:
+    """`(next command, why)` for a leg missing a shape file.
 
     A COPY IS OFFERED ONLY FOR A FILE A COPY WOULD FIX -- `cp` for a POSIX
     reader and `Copy-Item -LiteralPath` for a PowerShell one, which is
@@ -3566,11 +3629,20 @@ def missing_shape_file_fix(ctx: Context, missing: list) -> str:
     those the row says what the file IS, and the repair is a human's until the
     repair mode lands.
 
+    AND THE COMMAND IS A COMMAND (#277). Where every missing file is
+    rendered, the NEXT used to be that sentence itself -- prose in the
+    command's place, with a whole command in backticks inside it, which an
+    interactive zsh pasted as command substitution. It is now the
+    `scaffold-project.py --help` the sentence names, and the sentence is the
+    `why`; so is the note a partial copy used to carry after `   # `.
+
     Split out of `check_leg_shape_files` for #134.
     """
     copyable = [entry for entry in missing if entry[2] not in LEG_RENDERED]
     if not copyable:
-        return (f"the missing file(s) are RENDERED per project from "
+        return (f"{PYTHON} {quote_arg(ctx.shape / 'scaffold-project.py')} "
+                "--help",
+                f"the missing file(s) are RENDERED per project from "
                 f"templates/<role>-root/ — `{PYTHON} "
                 f"{quote_arg(ctx.shape / 'scaffold-project.py')} --help` "
                 "shows what writes them; copying a template verbatim "
@@ -3580,10 +3652,10 @@ def missing_shape_file_fix(ctx: Context, missing: list) -> str:
     source = ctx.shape / "templates" / f"{role}-root" / name
     fix = copy_command(source, ctx.root / rel / name)
     if len(copyable) < len(missing):
-        fix += ("   # and the rest are RENDERED per project "
-                "(placeholders): scaffold-project.py writes those, "
-                "and copying a template verbatim would not")
-    return fix
+        return fix, ("and the rest are RENDERED per project "
+                     "(placeholders): scaffold-project.py writes those, "
+                     "and copying a template verbatim would not")
+    return fix, None
 
 
 def check_leg_shape_files(ctx: Context) -> Row:
@@ -3630,9 +3702,9 @@ def check_leg_shape_files(ctx: Context) -> Row:
         # so every project cut before that template existed was failed by a
         # rule this standard never made. The difference is worth a reader's
         # eye and is not a verdict.
+        fix, why = missing_shape_file_fix(ctx, missing)
         return Row("leg-shape-files", LABEL_LEG_SHAPE_FILES, NOTE,
-                   f"{summary}  (missing: {named})",
-                   missing_shape_file_fix(ctx, missing), detail)
+                   f"{summary}  (missing: {named})", fix, detail, why=why)
     return Row("leg-shape-files", LABEL_LEG_SHAPE_FILES, OK, summary, None,
                detail)
 
@@ -4028,7 +4100,7 @@ def misplaced_submodule(item: dict) -> dict:
 
 
 def placement_row(status: str, reason: str, next_command=None,
-                  detail=None) -> Row:
+                  detail=None, why=None) -> Row:
     """One `placement` row with the `--json` keys ALWAYS present.
 
     A caller reads `detail.misplaced` and `detail.review_required`; a row that
@@ -4044,7 +4116,8 @@ def placement_row(status: str, reason: str, next_command=None,
             "misplaced": [], "review_required": [],
             "counts": {"misplaced": 0, "review_required": 0}}
     base.update(detail or {})
-    return Row("placement", "placement", status, reason, next_command, base)
+    return Row("placement", "placement", status, reason, next_command, base,
+               why=why)
 
 
 def leg_submodules(policy, role: str, rel: str, held: list,
@@ -4281,9 +4354,10 @@ def placement_policy(ctx: Context, policy_path: Path) -> tuple:
             f"this checkout of the standard is missing {missing}, so the "
             "adoption's own classification cannot be run over the legs",
             f"{PYTHON} {quote_arg(ctx.shape / 'shape-doctor.py')} --root "
-            f"{quote_arg(ctx.root)}   # from a COMPLETE checkout of the "
-            f"standard; this one is short {missing}",
-            {"policy": policy_path.as_posix()})
+            f"{quote_arg(ctx.root)}",
+            {"policy": policy_path.as_posix()},
+            why=f"from a COMPLETE checkout of the standard; this one is "
+                f"short {missing}")
     try:
         policy = adopt.PathPolicy.load(policy_path)
     except Refusal as exc:
@@ -4362,7 +4436,8 @@ def submodules_verdict(detail: dict, audited: str) -> Row:
         NOTE, f"nothing is in the wrong leg{held}  [{audited}]", None, detail)
 
 
-def placement_verdict(detail: dict, audited: str, plan: str) -> Row:
+def placement_verdict(detail: dict, audited: str, plan: str,
+                      plan_why: str) -> Row:
     """What the audited legs add up to, in the order the answers outrank.
 
     A PATH IN THE WRONG LEG OUTRANKS A QUESTION ABOUT ONE. Misplaced first
@@ -4398,7 +4473,9 @@ def placement_verdict(detail: dict, audited: str, plan: str) -> Row:
 
     Reads what it needs out of `detail` rather than taking the same six
     numbers a second time: the row prints that dictionary, so a count this
-    judged on and a count the reader is shown cannot drift apart.
+    judged on and a count the reader is shown cannot drift apart. `plan` is
+    the `--placement-plan` command and `plan_why` what it does, which travel
+    together onto every row that offers the plan (#277).
 
     Split out of `check_placement` for #134.
     """
@@ -4420,13 +4497,13 @@ def placement_verdict(detail: dict, audited: str, plan: str) -> Row:
         return placement_row(
             FINDING, f"{misplaced_clauses(misplaced)}{extra}{held}  "
             f"[{audited}]",
-            plan, detail)
+            plan, detail, plan_why)
     if review:
         return placement_row(
             NOTE,
             f"nothing is in the wrong leg; {len(review)} path(s) the policy "
             f"will not call: {named_offenders(review)}{held}  [{audited}]",
-            plan, detail)
+            plan, detail, plan_why)
     if counts["unread_legs"] or counts["unwritable_names"]:
         # `note`, because what is missing is a READ and not a fault of this
         # repository's -- and never `ok`, because "every tracked path
@@ -4549,11 +4626,12 @@ def check_placement(ctx: Context) -> Row:
     audited = "; ".join(leg_audit_summary(entry) for entry in per_leg)
     plan = (f"{PYTHON} {quote_arg(ctx.shape / 'shape-doctor.py')} --root "
             f"{quote_arg(ctx.root)} "
-            "--placement-plan placement-plan.yaml   # writes the paths above "
-            "as a plan to resolve by hand. Moving one is a pull request on "
-            "each leg and a pin bump in the root, so this command makes "
-            "neither")
-    return placement_verdict(detail, audited, plan)
+            "--placement-plan placement-plan.yaml")
+    return placement_verdict(
+        detail, audited, plan,
+        "writes the paths above as a plan to resolve by hand. Moving one is "
+        "a pull request on each leg and a pin bump in the root, so this "
+        "command makes neither")
 
 
 #: The header of the file `--placement-plan` writes. It is long because the
@@ -4904,10 +4982,13 @@ def check_agent_files(ctx: Context) -> Row:
     # `update-shape.py`, and `--add` refuses it BY NAME as already pinned; a
     # path with no row is `upstream-added`, which is exactly what `--add`
     # takes (Copilot, PR #96).
+    # Each branch is the COMMAND and, apart from it, the sentence that says
+    # why it is that command (#277).
     if detail["pinned"]:
         first = detail["pinned"][0]
         fix = (f"git -C {quote_arg(ctx.root)} checkout -- "
-               f"{quote_arg(first)}   # the pin has a "
+               f"{quote_arg(first)}")
+        why = ("the pin has a "
                "`files:` row for it, so it was deleted rather than never "
                "copied; restore it from this repository's own history, then "
                f"`{PYTHON} "
@@ -4916,12 +4997,14 @@ def check_agent_files(ctx: Context) -> Row:
     elif "AGENTS-shape.md" in absent:
         fix = (f"{PYTHON} {quote_arg(ctx.shape / 'update-shape.py')} "
                f"check --root {quote_arg(ctx.root)} --upstream "
-               f"{quote_arg(ctx.shape)}   # no pin row names it, "
+               f"{quote_arg(ctx.shape)}")
+        why = ("no pin row names it, "
                "so it is reported upstream-added and taken, on the human's "
                "word, with `apply --add AGENTS-shape.md`")
     else:
         fix = (f"{PYTHON} {quote_arg(ctx.shape / 'scaffold-project.py')} "
-               f"--help   # {' and '.join(absent)} is RENDERED per project, "
+               "--help")
+        why = (f"{' and '.join(absent)} is RENDERED per project, "
                "not copied; "
                "write it, or take a rendered one from a scaffolded root")
     # FINDING ONLY FOR A FILE SOMETHING ELSE ASSERTS. `AGENTS-shape.md` is a
@@ -4933,7 +5016,7 @@ def check_agent_files(ctx: Context) -> Row:
     # along.
     status = FINDING if detail["pinned"] else NOTE
     return Row("agent-files", LABEL_AGENT_FILES, status,
-               "absent: " + ", ".join(absent), fix, detail)
+               "absent: " + ", ".join(absent), fix, detail, why=why)
 
 
 def detached(path: Path) -> bool | None:
@@ -5334,26 +5417,27 @@ def members_verdict(ctx: Context, detail: dict, members_dir: str,
         # what the plain git line does AND carries the credential rewrite a
         # PRIVATE member needs (`fetch_members`), so replacing it would
         # trade a missing script for a fetch that fails on a private member.
+        # Each branch is the COMMAND and, apart from it, the sentence that
+        # says why it is that command (#277).
         if checkout and own_bootstrap(ctx.root):
             next_command = (
                 f"{PYTHON} "
                 f"{quote_arg(ctx.root / 'scripts' / 'bootstrap.py')} "
-                f"--root {quote_arg(ctx.root)}   # what `make bootstrap` "
-                "runs in a holder: it fetches every member at its pin and "
-                "leaves it detached there")
+                f"--root {quote_arg(ctx.root)}")
+            why = ("what `make bootstrap` runs in a holder: it fetches every "
+                   "member at its pin and leaves it detached there")
         elif checkout:
             after = (". This holder has no scripts/bootstrap.py that can "
                      "run, so this is the plain git line, with no "
                      "credential rewrite for a private member")
-            line, why = submodule_update_next(ctx.root, checkout, off_pin,
-                                              "member", after, lockstep)
-            next_command = f"{line}   # {why}"
+            next_command, why = submodule_update_next(
+                ctx.root, checkout, off_pin, "member", after, lockstep)
         else:
             # THE FAMILY GATE, one definition of it for this row and the
             # `family` row (`lockstep_next`).
-            next_command = lockstep_next(ctx, FAMILY_GATE, "member")
+            next_command, why = lockstep_next(ctx, FAMILY_GATE, "member")
         return Row("members", "members", FINDING, reason, next_command,
-                   detail)
+                   detail, why=why)
     note = f"{len(rows)} member(s) mounted at their pins"
     if on_a_branch:
         note += ("; on a BRANCH rather than detached: "
@@ -5692,12 +5776,12 @@ def check_machine(ctx: Context) -> Row:
     reason = f"{ready} (setup-project.py --preflight, exit {code}){extra}"
     if code != 0 and quoted:
         reason += f": {quoted}"
+    if code == 0:
+        return Row("machine", "machine", NA, reason, None, detail)
     return Row("machine", "machine", NA, reason,
-               None if code == 0 else
-               f"{PYTHON} {quote_arg(entry)} --preflight   # it names each "
-               "missing prerequisite and offers to install it, on a typed "
-               "yes",
-               detail)
+               f"{PYTHON} {quote_arg(entry)} --preflight", detail,
+               why="it names each missing prerequisite and offers to install "
+                   "it, on a typed yes")
 
 
 def python_command(platform: str | None = None) -> str:
@@ -5876,7 +5960,7 @@ def check_the_way_in(ctx: Context) -> Row:
         # above a `Triad` row that says "work from its assembly root" would
         # be this report contradicting itself (#164 review). No `next` here:
         # the Triad row names the root to work from.
-        fix = None
+        fix = why = None
         reason = ("this is a git repository with no shape manifest, NAMED OR "
                   "WRITTEN AS A LEG: a leg is not adopted or scaffolded on "
                   "its own -- see the Triad row for its assembly root")
@@ -5884,19 +5968,21 @@ def check_the_way_in(ctx: Context) -> Row:
         fix = (f"{PYTHON} {quote_arg(ctx.shape / 'adopt-project.py')} "
                f"plan --source {quote_arg(root)} --project "
                f"{quote_arg(project)}")
+        why = None
         reason = ("this is a git repository with no shape manifest: it is "
                   "ADOPTED in place, keeping its name, identity and history")
     else:
         # `<your-org>` IS NOT QUOTED and must not be: it is a placeholder
         # the reader replaces, not a value this command knows. Quoting it
         # would tell them to type the angle brackets.
-        fix = (scaffold_command(ctx.shape, project)
-               + "   # without --yes; it asks")
+        fix = scaffold_command(ctx.shape, project)
+        why = "without --yes; it asks"
         reason = ("there is no repository here to adopt: a new project is "
                   "SCAFFOLDED, which creates three repositories and asks "
                   "first")
     return Row("way-in", "the way in", NA, reason, fix,
-               {"git_repository": is_repo, "suggested_project": project})
+               {"git_repository": is_repo, "suggested_project": project},
+               why=why)
 
 
 #: Named once, like `LABEL_MANIFEST_KINDS` above: this function's three
@@ -6476,6 +6562,11 @@ def report(ctx: Context, rows: list[Row], verdict: str, code: int,
         if row.next_command:
             print(f"  {'':<{status_width}}  {'NEXT':<{width}}  "
                   f"{row.next_command}")
+        # A LINE OF ITS OWN, UNDER THE COMMAND AND NEVER ON IT (#277): what
+        # follows a NEXT on its line is pasted with it, and an interactive
+        # zsh runs it.
+        if row.why:
+            print(f"  {'':<{status_width}}  {'WHY':<{width}}  {row.why}")
     print()
     # BEFORE THE VERDICT, because the verdict is the conclusion and reads
     # last, and this line belongs with the row it came out of.
@@ -6497,6 +6588,11 @@ def report(ctx: Context, rows: list[Row], verdict: str, code: int,
         # to do instead; `Remediation: None` was a literal `None` after it.
         if blocked.next_command:
             print(f"  Remediation: {blocked.next_command}", file=sys.stderr)
+        # AND ITS `why` WHENEVER IT HAS ONE, Remediation or not (#277): the
+        # sentence is about the row, and a row with no command to paste can
+        # still have something to say about the one it does not offer.
+        if blocked.why:
+            print(f"  Why: {blocked.why}", file=sys.stderr)
 
 
 #: The line NOT A SHAPE ROOT adds, and the one thing in this file that is
diff --git a/tests/test_doctor_legs_members_next.py b/tests/test_doctor_legs_members_next.py
index 2df2d05f..54670422 100644
--- a/tests/test_doctor_legs_members_next.py
+++ b/tests/test_doctor_legs_members_next.py
@@ -28,9 +28,9 @@
 submodule URL by default -- and never `GIT_ALLOW_PROTOCOL`, which would
 override git's `user` policy for the whole run.
 
-WHAT IS ASSERTED IS WHAT THE COMMAND DOES, and the explanation after it is
+WHAT IS ASSERTED IS WHAT THE COMMAND DOES, and the explanation beside it is
 read through `why_of` alone, so that moving the `   # ` tail into a field of
-its own (#277) changes one helper here and not every test.
+its own (#277) changed one helper here and not every test.
 
 The fixtures are `test_shape_doctor`'s, imported rather than rebuilt: a
 project or a holder made any other way would be a different one.
@@ -66,9 +66,6 @@
              "GIT_CONFIG_VALUE_0": "always",
              "PYTHONDONTWRITEBYTECODE": "1"}
 
-#: The three characters between a NEXT's command and its explanation.
-TAIL = "   # "
-
 #: The git line's own words after `git -C <root>`: `--init` for a mount the
 #: clone never registered, `--recursive` for a member's own legs, and
 #: `--checkout` so that a configured `submodule.<name>.update` (rebase, merge,
@@ -79,14 +76,15 @@
 # --- reading a row ----------------------------------------------------------
 
 def command_of(row: dict) -> str:
-    """The command a row hands over, without its explanation."""
-    return (row["next"] or "").partition(TAIL)[0]
+    """The command a row hands over: its NEXT, which is only the command
+    (#277)."""
+    return row["next"] or ""
 
 
 def why_of(row: dict) -> str:
-    """The sentence that explains the command: today the `   # ` tail, and
-    the row's own `why` once #277 moves it there."""
-    return row.get("why") or (row["next"] or "").partition(TAIL)[2]
+    """The sentence that explains the command: the row's own `why`, which
+    used to be the NEXT's `   # ` tail (#277)."""
+    return row["why"] or ""
 
 
 def row_of(standard: Path, root: Path, row_id: str) -> dict:
diff --git a/tests/test_doctor_next_is_a_command.py b/tests/test_doctor_next_is_a_command.py
new file mode 100644
index 00000000..44fc7bd5
--- /dev/null
+++ b/tests/test_doctor_next_is_a_command.py
@@ -0,0 +1,1009 @@
+# SPDX-License-Identifier: Apache-2.0
+"""A doctor NEXT is the command and only the command (#277).
+
+THE DEFECT. Twenty-nine of the doctor's NEXT builders ended the command with
+`   # <comment>`, and one printed prose in the command's place. Sixteen were
+there when this began (3ae0109). Doctor A (#276) then rewrote the `legs`
+tail and added two more (`lockstep_next` and the `members` git line), doctor
+B (#278, #298) added two (its crash line and its restore line), and lane 2's
+#237 (#267) added five, which landed while this was in CI (`pin_restore`
+four times and `unreadable_pin_row`). Lane 2's #291 then added four, which
+landed while this waited to land: `pin_restore`'s three `git diff` lines
+for a file a person may have edited, and `unreadable_next`'s line for one
+no git command can put back. Lane 2's #496 rewrote the first of #267's,
+which now takes the pin alone and gives a copy conflicted beside it to a
+person. A tail was harmless in exactly the shells that read `#` as a
+comment where a word starts -- `sh -c`, bash, `zsh -c` -- which is how
+every test and every agent tool call had read one. An
+INTERACTIVE zsh without `interactivecomments` -- zsh's default, and macOS's
+login shell, the one a person pastes into -- reads `#` as a word. Pasted
+there, the manifest NEXT handed `# read its output in full` to the
+validator as arguments, ran `it names what it refused` as a second command
+and exited 127; the `legs` and `members` NEXTs ran the `make bootstrap`
+their comments put in backticks, in whatever directory the person was
+standing in.
+
+THE FIX IS A FIELD, NOT A SPELLING. Each sentence moved, verbatim, to the
+row's `why` -- `"why"` in `--json`, a `WHY` line under `NEXT` in the table,
+`Why:` after `Remediation:` -- and `next` is the bare command. So this file
+holds three things, and the code before #277 fails each of them:
+
+  * a PROPERTY over one fixture per converted builder and branch: the NEXT
+    has no shell comment (`shlex` reads it the same with and without
+    comments), no backtick, no `$(` that `sh` would run and, on POSIX, none
+    of `;`, `&`, `|`, `(`, `)` outside a quotation (PowerShell's `$env:`
+    line ends its assignment with a `;`, by design);
+  * a PASTE into `zsh -f -i` through a pty, as a person pastes: the manifest
+    NEXT is the validator's own finding and exit, and the legs NEXT, pasted
+    in a directory whose Makefile's `bootstrap` target leaves a marker,
+    leaves none -- each beside a line the doctor printed before #277, pasted
+    the same way, so the harness is shown to see the defect it guards;
+  * an AST GUARD over `shape-doctor.py`: no string that is not a docstring
+    holds a tail -- two or more blanks, or a tab, then `#` and a blank --
+    except `placement_plan_leg`'s YAML comment lines and the one `placement
+    plan written to` line in `report`, where that text is not a NEXT. It is
+    what turns a tail landed later, by any lane, into a red test.
+
+The fixtures are `tests/test_shape_doctor.py`'s, imported rather than rebuilt
+(the precedent is `tests/test_family_add_refusals.py`); importing a fixture
+gives this module its own instance of it.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import re
+import select
+import shlex
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+import pytest
+
+from conftest import REPO, WINDOWS_SKIP, git, rmtree
+#: The lane a lane's run sets, from the file that owns that rule.
+from test_commit_trailers import LANE
+#: The doctor's own fixtures and helpers, from the module that owns them. A
+#: project or a holder made any other way would be a different project.
+from test_shape_doctor import (  # noqa: F401
+    BREAKAGES, DOCTOR, DRIFT_TARGET, FAMILY_MEMBER, FAMILY_NAME,
+    GIT_IDENTITY, SHAPE_PIN, UPSTREAM_TARGET, behind_row, break_manifest,
+    break_the_pin, doctor, doctor_module, holder, not_forty_hex, pin_with,
+    project, recommit_a_good_pin, red_root, rows_of, scaffolded_here, stage,
+    standard, standard_ahead, standard_of_another_history,
+)
+#: Lane 2's ways to make a file under `contracts/` not load (#291), from the
+#: module that owns them: the `manifest kinds` row's NEXTs are #291's, so the
+#: roots are too.
+from test_shape_doctor import (
+    NAMING_COPY, PROJECT_LINE, SLIP, SPEC_PIN, a_copy_conflicted_on_its_own,
+    append_to, conflict_in, insert_after_first_line, leg_pin_not_utf8,
+    own_pin_named_edited_with_a_slip,
+)
+#: Doctor A's ways to make a leg or a member red (#276), from the module that
+#: owns them: the `legs` and `members` lines are A's, so the roots are too.
+#: Its `commit_in(root, message)` commits whatever is staged, with an
+#: identity of its own, which is all the pin's history below needs of one.
+from test_doctor_legs_members_next import (
+    commit_in, holder_copy, holder_without, make_gitlink_moved,
+    make_member_gitlink_mismatch, member_unbootstrapped,
+)
+#: Doctor B's crashing validator and unloaded manifest (#278, #298), from the
+#: module that owns them.
+from test_doctor_validator_rows import crashing, unloaded
+
+
+# --- making each converted row print its NEXT -------------------------------
+
+def a_short_standard(tmp_path: Path, name: str) -> Path:
+    """A directory standing in for a standard that lacks what a row needs:
+    what the doctor's own checkout cannot be made to lack in a test."""
+    short = tmp_path / name
+    short.mkdir()
+    return short
+
+
+def _validator_neither_readable(standard, project, holder, tmp_path):
+    # Neither the root's copy nor the standard's is there: a validator name
+    # nothing carries, asked of the builder itself.
+    module = doctor_module(standard)
+    ctx = module.Context(project.resolve())
+    return module.validator_row(
+        ctx, "manifest", "manifest", "scripts/validate-nothing.py",
+        "templates/assembly-root/scripts/validate-nothing.py",
+        ["--root", str(ctx.root)]).as_dict()
+
+
+def _validator_own_copy(standard, project, holder, tmp_path):
+    root = red_root("manifest", project, holder, tmp_path, keep_own=True)
+    return rows_of(doctor(standard, root, "--json"))["manifest"]
+
+
+def _validator_template_copy(standard, project, holder, tmp_path):
+    root = red_root("pins", project, holder, tmp_path)
+    return rows_of(doctor(standard, root, "--json"))["pins"]
+
+
+def _unloaded_manifest(standard, project, holder, tmp_path):
+    edit, code = BREAKAGES["tab-indent"]
+    break_manifest(project.resolve() / "project.yaml", edit, code)
+    return rows_of(doctor(standard, project, "--json"))["manifest"]
+
+
+def _unloaded_manifest_neither_readable(standard, project, holder, tmp_path):
+    # The branch that hands on `validator_row`'s NEXT -- and now its `why`.
+    edit, code = BREAKAGES["tab-indent"]
+    break_manifest(project.resolve() / "project.yaml", edit, code)
+    module = doctor_module(standard)
+    ctx = module.Context(project.resolve())
+    assert ctx.manifest_refusal is not None, "the manifest still loads"
+    return module.unloaded_manifest_row(
+        ctx, "manifest", "manifest", "scripts/validate-nothing.py",
+        "templates/assembly-root/scripts/validate-nothing.py").as_dict()
+
+
+def _shape_currency_cannot_answer(standard, project, holder, tmp_path):
+    stranger = standard_of_another_history(standard, tmp_path)
+    return rows_of(doctor(stranger, project, "--json"))["shape-currency"]
+
+
+def _shape_currency_behind_pin_only(standard, project, holder, tmp_path):
+    # Run inside a lane, so the `apply` grows its trailer -- which is `why`'s
+    # to carry now, and never `next`'s.
+    row = behind_row(standard_ahead(standard, tmp_path), project, LANE)
+    assert row["detail"].get("behind_pin_only") is True, row
+    assert row["why"].endswith(f" --trailer 'Lane: {LANE}'"), row["why"]
+    return row
+
+
+def _shape_currency_moved(standard, project, holder, tmp_path):
+    ahead = standard_ahead(standard, tmp_path, UPSTREAM_TARGET,
+                           "\n# an upstream fix, after this project was cut\n",
+                           "An upstream fix to a copied file")
+    edited = project / DRIFT_TARGET
+    edited.write_text(edited.read_text(encoding="utf-8")
+                      + "\n# a local edit nobody carried upstream\n",
+                      encoding="utf-8")
+    row = behind_row(ahead, project, LANE)
+    # The `apply` -- its `--accept-local` and the lane's trailer with it --
+    # is the row's `why`, and nothing of it is on the NEXT.
+    assert f"--accept-local {DRIFT_TARGET}" in row["why"], row["why"]
+    assert row["why"].endswith(f" --trailer 'Lane: {LANE}'"), row["why"]
+    for moved in ("apply", "--accept-local", "--trailer"):
+        assert moved not in row["next"], (moved, row["next"])
+    return row
+
+
+def _legs(standard, project, holder, tmp_path):
+    # A leg committed past its pin where the gitlink IS the pin: doctor A's
+    # git line, which a checkout cures (#276).
+    commit_in(project / "spec")
+    return rows_of(doctor(standard, project, "--json"))["legs"]
+
+
+def _legs_lockstep(standard, project, holder, tmp_path):
+    # A gitlink that is not the pin, which no checkout cures: doctor A's
+    # lockstep line, the root's own `validate-pins.py` (`lockstep_next`).
+    make_gitlink_moved(project)
+    return rows_of(doctor(standard, project, "--json"))["legs"]
+
+
+def _leg_shape_files_partly_copyable(standard, project, holder, tmp_path):
+    (project / "spec" / "AGENTS.md").unlink()
+    (project / "spec" / "CLAUDE.md").unlink()
+    return rows_of(doctor(standard, project, "--json"))["leg-shape-files"]
+
+
+def _leg_shape_files_all_rendered(standard, project, holder, tmp_path):
+    # The NEXT that WAS prose, with a command in backticks inside it.
+    (project / "spec" / "AGENTS.md").unlink()
+    row = rows_of(doctor(standard, project, "--json"))["leg-shape-files"]
+    # The `--help` the sentence names, now the command itself. Its path may
+    # be quoted (a Windows temporary directory is), so read as words.
+    words = row["next"].split()
+    assert words[-1] == "--help" and "scaffold-project.py" in words[-2], \
+        row["next"]
+    return row
+
+
+def _placement_policy_missing(standard, project, holder, tmp_path):
+    module = doctor_module(standard)
+    ctx = module.Context(project.resolve())
+    ctx.shape = a_short_standard(tmp_path, "a-standard-without-adopt")
+    adopt, _policy, row = module.placement_policy(
+        ctx, ctx.shape / "contracts" / "path-classification.yaml")
+    assert adopt is None and row is not None, row
+    return row.as_dict()
+
+
+def _placement_plan(standard, project, holder, tmp_path):
+    stage(project / "spec", "tool.py", "VALUE = 1\n")
+    return rows_of(doctor(standard, project, "--json"))["placement"]
+
+
+def _agent_files_pinned(standard, project, holder, tmp_path):
+    (project / "AGENTS-shape.md").unlink()
+    return rows_of(doctor(standard, project, "--json"))["agent-files"]
+
+
+def _agent_files_unpinned(standard, project, holder, tmp_path):
+    # No `contracts/shape-pin.yaml` names `AGENTS-shape.md`: the branch
+    # that sends the reader to `update-shape.py check` and `apply --add`.
+    module = doctor_module(standard)
+    here = tmp_path / "unpinned"
+    here.mkdir()
+    for name in ("AGENTS.md", "CLAUDE.md"):
+        (here / name).write_text("an agent file\n", encoding="utf-8")
+    return module.check_agent_files(module.Context(here)).as_dict()
+
+
+def _agent_files_rendered(standard, project, holder, tmp_path):
+    (project / "CLAUDE.md").unlink()
+    return rows_of(doctor(standard, project, "--json"))["agent-files"]
+
+
+def _members(standard, project, holder, tmp_path):
+    root = tmp_path / FAMILY_NAME
+    shutil.copytree(holder["root"], root, symlinks=True)
+    mount = root / "members" / FAMILY_MEMBER
+    rmtree(mount)
+    mount.mkdir()
+    return rows_of(doctor(standard, root, "--json"))["members"]
+
+
+def _members_git_line(standard, project, holder, tmp_path):
+    # A holder whose own bootstrap cannot run: doctor A's plain git line.
+    root = holder_copy(holder, tmp_path)
+    holder_without(root, "bootstrap.py")
+    member_unbootstrapped(root)
+    return rows_of(doctor(standard, root, "--json"))["members"]
+
+
+def _members_lockstep(standard, project, holder, tmp_path):
+    # A member whose gitlink is not its pin: the family gate, through the
+    # same `lockstep_next` as the `legs` row.
+    root = holder_copy(holder, tmp_path)
+    make_member_gitlink_mismatch(root)
+    return rows_of(doctor(standard, root, "--json"))["members"]
+
+
+def _validator_crashed(standard, project, holder, tmp_path):
+    # The root's own `validate-pins.py` raising: doctor B's crash line (#278).
+    here, root, row_id, _own = crashing("own-pins", standard, project, holder,
+                                        tmp_path)
+    return rows_of(doctor(here, root, "--json"))[row_id]
+
+
+def _unloaded_manifest_restore(standard, project, holder, tmp_path):
+    # A manifest that does not load and a gate whose `repo_shape.py` is gone
+    # from the tree, which HEAD still holds: doctor B's restore line (#298).
+    root, row_id, _refusal = unloaded("project", project, holder, tmp_path,
+                                      "tree")
+    return rows_of(doctor(standard, root, "--json"))[row_id]
+
+
+def _pin_row(standard, root, restore):
+    """The `shape currency` row for a root whose OWN pin does not read, and
+    the proof that the fixture reached the branch it was made for."""
+    row = rows_of(doctor(standard, root, "--json"))["shape-currency"]
+    assert row["detail"]["restore"] == restore, row["detail"]
+    return row
+
+
+def _pin_unmerged(standard, project, holder, tmp_path):
+    # The issue's own reproduction: two branches rewrite `commit:`, then merge.
+    # Lane 2's `pin_restore`, #237: the pin is `UU`, and the NEXT takes one
+    # side of it whole.
+    base = git("rev-parse", "HEAD", cwd=project).stdout.strip()
+    for branch, digit in (("edit-a", "1"), ("edit-b", "2")):
+        git("checkout", "-q", "-b", branch, base, cwd=project)
+        break_the_pin(project, pin_with(r'^commit: .*$',
+                                        f'commit: "{digit * 40}"'))
+        git("add", "--", SHAPE_PIN, cwd=project)
+        commit_in(project, branch)
+    merged = subprocess.run(["git", "merge", "-q", "edit-a"],
+                            cwd=str(project), capture_output=True, text=True,
+                            check=False, env={**os.environ, **GIT_IDENTITY})
+    assert merged.returncode != 0, merged.stdout + merged.stderr
+    return _pin_row(standard, project, "unmerged")
+
+
+def _pin_unmerged_copy_beside(standard, project, holder, tmp_path):
+    # #496 (#485): the pin and a copy it has a row for conflicted together.
+    # The NEXT takes the pin alone, and the `why` gives the copy to a
+    # person to merge by hand.
+    conflict_in(project, SHAPE_PIN, "commit", "Makefile")
+    row = _pin_row(standard, project, "unmerged")
+    assert row["detail"]["left_for_a_person"] == ["Makefile"], row
+    return row
+
+
+def _pin_uncommitted(standard, project, holder, tmp_path):
+    # HEAD holds a pin that reads and the tree differs from it: `checkout HEAD`.
+    break_the_pin(project, not_forty_hex)
+    return _pin_row(standard, project, "uncommitted")
+
+
+def _pin_hidden(standard, project, holder, tmp_path):
+    # HEAD's pin reads, the copy here is broken, and `git status` says
+    # nothing because an index flag hides it: the `ls-files -v` that shows
+    # which.
+    recommit_a_good_pin(project)
+    git("update-index", "--assume-unchanged", "--", SHAPE_PIN, cwd=project)
+    break_the_pin(project, not_forty_hex)
+    return _pin_row(standard, project, "hidden")
+
+
+def _pin_committed(standard, project, holder, tmp_path):
+    # A commit broke the pin: `checkout <that commit>~1`.
+    break_the_pin(project, not_forty_hex)
+    git("add", "--", SHAPE_PIN, cwd=project)
+    commit_in(project, "break the pin")
+    row = _pin_row(standard, project, "committed")
+    # The commit's own name is in the sentence, so it is read past: the
+    # words after it are asserted here, the words before it by CASES.
+    assert row["why"].endswith(
+        ", the commit that broke it, and the newest pin in its history that "
+        "reads. Commit that rather than editing the pin"), row["why"]
+    return row
+
+
+def _pin_no_history(standard, project, holder, tmp_path):
+    # One root commit holds a bad pin: nothing git can name puts one back, so
+    # `unreadable_pin_row` keeps the `update-shape.py check` it always had.
+    break_the_pin(project, not_forty_hex)
+    git("checkout", "-q", "--orphan", "squashed", cwd=project)
+    git("add", "--", SHAPE_PIN, cwd=project)
+    commit_in(project, "the whole history, squashed into one commit")
+    return _pin_row(standard, project, "none")
+
+
+def _kinds_row(standard, root, rel, restore):
+    """The `manifest kinds` row for a root where `rel` does not load, and the
+    proof that the fixture reached the branch it was made for (#291)."""
+    row = rows_of(doctor(standard, root, "--json"))["manifest-kinds"]
+    assert row["detail"]["restore"] == {rel: restore}, row["detail"]
+    return row
+
+
+def _pin_unmerged_shown(standard, project, holder, tmp_path):
+    # A copy the shape pin has a row for, conflicted on its own: the `diff`
+    # that shows the hunks git could not merge, and nothing taken whole.
+    a_copy_conflicted_on_its_own(project)
+    return _kinds_row(standard, project, NAMING_COPY, "unmerged")
+
+
+def _pin_uncommitted_shown(standard, project, holder, tmp_path):
+    # The copy's uncommitted change breaks it: the `diff HEAD` that shows it.
+    append_to(project / NAMING_COPY, SLIP)
+    return _kinds_row(standard, project, NAMING_COPY, "uncommitted")
+
+
+def _pin_committed_shown(standard, project, holder, tmp_path):
+    # A hand merge of the copy, committed with a slip: the `diff <it>~1`
+    # that shows every change since the newest copy that reads.
+    copy = project / NAMING_COPY
+    insert_after_first_line(copy, PROJECT_LINE)
+    append_to(copy, SLIP)
+    git("add", "--", NAMING_COPY, cwd=project)
+    commit_in(project, "the hand merge, with a slip")
+    return _kinds_row(standard, project, NAMING_COPY, "committed")
+
+
+def _unreadable_next_by_hand(standard, project, holder, tmp_path):
+    # A file of the project's own that does not load: no git command is
+    # named, and the NEXT is this doctor again.
+    rel, restore = own_pin_named_edited_with_a_slip(project)
+    return _kinds_row(standard, project, rel, restore)
+
+
+def _unreadable_next_restore(standard, project, holder, tmp_path):
+    # A leg pin that does not load: the branch of `unreadable_next` that
+    # hands on `pin_restore`'s command and, now, its `why`.
+    leg_pin_not_utf8(project)
+    return _kinds_row(standard, project, SPEC_PIN, "uncommitted")
+
+
+def _machine(standard, project, holder, tmp_path):
+    # A preflight that is not ready, on every host: whether the real one is
+    # depends on the machine, and the row's NEXT only exists when it is not.
+    module = doctor_module(standard)
+    ctx = module.Context(project.resolve())
+    ctx.shape = a_short_standard(tmp_path, "a-standard-not-ready")
+    (ctx.shape / "setup-project.py").write_text(
+        "import sys\nprint('[!!] a prerequisite is missing')\nsys.exit(1)\n",
+        encoding="utf-8")
+    return module.check_machine(ctx).as_dict()
+
+
+def _way_in(standard, project, holder, tmp_path):
+    here = tmp_path / "Loose"
+    here.mkdir()
+    (here / "notes.txt").write_text("nothing to see\n", encoding="utf-8")
+    return rows_of(doctor(standard, here, "--json"))["way-in"]
+
+
+#: One fixture per NEXT #277 converted, by the builder and branch it reaches,
+#: and how the sentence that used to follow `   # ` on it now opens -- moved
+#: VERBATIM, less the `#`, so these are the words main, doctors A and B and
+#: lane 2's #237, #291 and #496 printed. Not the prose NEXTs
+#: `check_manifest_kinds` prints for a kind no gate here runs (#211, #327),
+#: and not a `Refusal.remediation` printed as one; its NEXT for a file that
+#: does not load (#291's `unreadable_next`) is here.
+CASES = {
+    "validator_row-neither-readable": (
+        _validator_neither_readable,
+        "from a complete checkout of the standard; this one is missing that "
+        "file"),
+    "validator_row-own-copy": (
+        _validator_own_copy,
+        "read its output in full; it names what it refused"),
+    "validator_row-template-copy": (
+        _validator_template_copy,
+        "read its output in full; it names what it refused"),
+    "unloaded_manifest_row": (
+        _unloaded_manifest, "the file to fix is "),
+    "unloaded_manifest_row-neither-readable": (
+        _unloaded_manifest_neither_readable,
+        "from a complete checkout of the standard; this one is missing that "
+        "file"),
+    "pin_restore-unmerged": (
+        _pin_unmerged,
+        "--theirs takes the other side. Take one side of the pin whole and "
+        "never a hand-merged pin, then finish the merge as git says and run "
+        "this doctor again"),
+    "pin_restore-unmerged-copy-beside": (
+        _pin_unmerged_copy_beside,
+        "--theirs takes the other side. Take one side of the pin whole and "
+        "never a hand-merged pin. Makefile is a copy conflicted too. A copy "
+        "can hold an edit of the project"),
+    "pin_restore-uncommitted": (
+        _pin_uncommitted,
+        "puts back the pin as last committed and discards the uncommitted "
+        "change that broke it, which no tool of this standard writes"),
+    "pin_restore-hidden": (
+        _pin_hidden,
+        "HEAD holds a pin that reads and git status shows no change to the "
+        "copy here, so no commit broke it and nothing in history is put "
+        "back. S in the first column is skip-worktree, as a sparse checkout "
+        "sets it, and a lowercase h is assume-unchanged: either hides the "
+        "copy here from git. Any other letter means the file itself cannot "
+        "be read, as the refusal says. Clearing that is for a person, then "
+        "run this doctor again"),
+    "pin_restore-committed": (_pin_committed, "the pin as it was before "),
+    "unreadable_pin_row": (
+        _pin_no_history,
+        "no commit in this root holds a pin to put back, so whether it was "
+        "ever scaffolded or adopted is for a person to decide"),
+    "pin_restore-unmerged-shown": (
+        _pin_unmerged_shown,
+        "a merge left the copy conflicted, and this shows the hunks git could "
+        "not merge. A copy can hold an edit of the project"),
+    "pin_restore-uncommitted-shown": (
+        _pin_uncommitted_shown,
+        "HEAD holds a copy that reads, and this shows the uncommitted change "
+        "that breaks the copy here. A copy can hold an edit of the project"),
+    "pin_restore-committed-shown": (
+        _pin_committed_shown,
+        "the newest copy in its history that reads is the one before "),
+    "unreadable_next": (
+        _unreadable_next_by_hand,
+        "the reason names each file that does not load and why, and none is a "
+        "file this root declares a tool writes with a copy that reads in its "
+        "history, so what each should say -- a merge conflict resolved, a "
+        "hand edit put right -- is for a person to decide. This row reads "
+        "them again once they load"),
+    "unreadable_next-pin_restore": (
+        _unreadable_next_restore,
+        "puts back the pin as last committed and discards the uncommitted "
+        "change that broke it, which no tool of this standard writes"),
+    "check_shape_currency-cannot-answer": (
+        _shape_currency_cannot_answer,
+        "this checkout of the standard does not carry the commit the pin "
+        "names; fetch it, or run the doctor from a clone that has it"),
+    "check_shape_currency-pin-alone-behind": (
+        _shape_currency_behind_pin_only, "then apply --at "),
+    "check_shape_currency-copies-moved": (
+        _shape_currency_moved, "then apply --at "),
+    "validator_row-crashed": (
+        _validator_crashed,
+        "read its output in full, it shows where the validator stopped"),
+    "unloaded_manifest_row-restore": (
+        _unloaded_manifest_restore,
+        "it puts back the scripts/repo_shape.py HEAD holds, the copy this "
+        "project committed and scripts/validate-manifest.py imports, where "
+        "update-shape.py apply would copy a newer one"),
+    "check_legs": (
+        _legs,
+        "checks each leg out at the commit this repository records for it, "
+        "and fetches a mount that is empty"),
+    "lockstep_next-legs": (
+        _legs_lockstep,
+        "no submodule update cures a leg whose gitlink or pin is missing or "
+        "disagrees, or a mount git cannot read a HEAD in. validate-pins.py "
+        "prints what it finds and names the repair where it has one"),
+    "missing_shape_file_fix-partly-copyable": (
+        _leg_shape_files_partly_copyable,
+        "and the rest are RENDERED per project (placeholders): "
+        "scaffold-project.py writes those, and copying a template verbatim "
+        "would not"),
+    "missing_shape_file_fix-all-rendered": (
+        _leg_shape_files_all_rendered,
+        "the missing file(s) are RENDERED per project from "
+        "templates/<role>-root/ -- `"),
+    "placement_policy": (
+        _placement_policy_missing,
+        "from a COMPLETE checkout of the standard; this one is short "
+        "adopt-project.py"),
+    "check_placement": (
+        _placement_plan,
+        "writes the paths above as a plan to resolve by hand. Moving one is a "
+        "pull request on each leg and a pin bump in the root, so this "
+        "command makes neither"),
+    "check_agent_files-pinned": (
+        _agent_files_pinned,
+        "the pin has a `files:` row for it, so it was deleted rather than "
+        "never copied; restore it from this repository's own history, then "),
+    "check_agent_files-unpinned": (
+        _agent_files_unpinned,
+        "no pin row names it, so it is reported upstream-added and taken, on "
+        "the human's word, with `apply --add AGENTS-shape.md`"),
+    "check_agent_files-rendered": (
+        _agent_files_rendered,
+        "CLAUDE.md is RENDERED per project, not copied; write it, or take a "
+        "rendered one from a scaffolded root"),
+    "members_verdict": (
+        _members,
+        "what `make bootstrap` runs in a holder: it fetches every member at "
+        "its pin and leaves it detached there"),
+    "members_verdict-git-line": (
+        _members_git_line,
+        "checks each member out at the commit this repository records for "
+        "it, and fetches a mount that is empty"),
+    "lockstep_next-members": (
+        _members_lockstep,
+        "no submodule update cures a member whose gitlink or pin is missing "
+        "or disagrees, or a mount git cannot read a HEAD in. "
+        "validate-family.py prints what it finds and names the repair where "
+        "it has one"),
+    "check_machine": (
+        _machine,
+        "it names each missing prerequisite and offers to install it, on a "
+        "typed yes"),
+    "check_the_way_in": (
+        _way_in, "without --yes; it asks"),
+}
+
+
+def unquoted_operators(command: str) -> list[str]:
+    """The control operators `sh` would act on in `command`: `;`, `&`, `|`,
+    `(`, `)`, `<`, `>`, outside any quotation.
+
+    `commenters` IS EMPTY ON PURPOSE. To an interactive zsh a `#` is a word,
+    so an operator after one is live there, and a reader that stopped at the
+    `#` the way `sh` does would wave through the very line #277 is about.
+    """
+    lexer = shlex.shlex(command, posix=True, punctuation_chars=True)
+    lexer.whitespace_split = True
+    lexer.commenters = ""
+    return [token for token in lexer
+            if token and set(token) <= set("();<>|&")]
+
+
+#: The operators a NEXT must not carry outside a quotation on POSIX: a list
+#: (`;`, `&`, `&&`, `|`, `||`) runs a second command, a parenthesis opens a
+#: subshell -- and an unquoted `$(` is read as `$` then the operator `(`,
+#: so it is one of them. `<` and `>` are not here: the way-in row's
+#: `<your-org>` is a placeholder the reader replaces, unquoted on purpose.
+LIVE_OPERATORS = ";&|()"
+
+
+def outside_single_quotes(command: str) -> str:
+    """`command` less what `sh` reads literally: single-quoted spans and the
+    character after a backslash. A `$(` left in it is run -- inside double
+    quotes as much as outside them -- which `shlex`'s tokens cannot show:
+    they read `"$(make)"` as the one word `$(make)`, exactly as they read
+    the quoted path `'$(make)'`, which runs nothing."""
+    kept, single, double, at = [], False, False, 0
+    while at < len(command):
+        char = command[at]
+        if single:
+            single = char != "'"
+        elif char == "\\":
+            at += 1
+        elif char == "'" and not double:
+            single = True
+        else:
+            double = double != (char == '"')
+            kept.append(char)
+        at += 1
+    return "".join(kept)
+
+
+def test_the_operator_readers_see_what_sh_runs_and_not_a_quoted_path():
+    """The property below is only as good as these two readers, so each is
+    shown to find an operator `sh` acts on, and to pass one that sits in a
+    quoted path."""
+    assert set("".join(unquoted_operators("a; b && c | d (e)"))) == set(
+        LIVE_OPERATORS)
+    assert unquoted_operators("git -C '/w/a;b&c|d (e)' status") == []
+    assert "(" in unquoted_operators("echo $(make)")
+    assert "$(" in outside_single_quotes('echo "$(make)"')
+    assert "$(" not in outside_single_quotes("echo '$(make)'")
+    assert "$(" not in outside_single_quotes("echo \\$(make)")
+    assert "$(" not in outside_single_quotes("echo 'it'\"'\"'s $(here)'")
+
+
+@pytest.mark.parametrize("case", list(CASES))
+def test_every_converted_next_is_a_command_and_nothing_else(
+        standard, project, holder, tmp_path, case):
+    """The property, over one red fixture per converted builder and branch.
+
+    NO SHELL COMMENT: `shlex` reads the line the same with comments on and
+    off, so nothing in it is a `#` where a word starts. NO BACKTICK, AND NO
+    `$(` THAT RUNS: command substitution in sh, bash and zsh alike. On
+    POSIX, NO `;`, `&`, `|`, `(` OR `)` OUTSIDE A QUOTATION, read from
+    `shlex`'s tokens so that a quoted path holding one is a path: what
+    followed a `;` in a tail was the second command an interactive zsh ran,
+    and the others start one too. AND THE SENTENCE IS NOT LOST: it is the
+    row's `why`, opening with the words printed after `   # ` before #277.
+    """
+    build, opens = CASES[case]
+    row = build(standard, project, holder, tmp_path)
+    command, why = row["next"], row["why"]
+    assert command, (case, row)
+    assert why and why.startswith(opens), (case, opens, why)
+    assert shlex.split(command, comments=True) == shlex.split(command), (
+        case, command)
+    assert "`" not in command, (case, command)
+    if os.name != "nt":
+        live = "".join(unquoted_operators(command))
+        for operator in LIVE_OPERATORS:
+            assert operator not in live, (case, operator, command)
+        assert "$(" not in outside_single_quotes(command), (case, command)
+    assert "   # " not in command, (case, command)
+
+
+# --- pasted, as a person pastes ---------------------------------------------
+
+#: The line the paste ends with, and what it prints: the status of the line
+#: before it. `$?` is never expanded in the echo of what was typed, so only
+#: the shell's own answer matches.
+PASTED_EXIT = re.compile(r"pasted-exit=(\d+)")
+
+
+def paste_into_zsh(line: str, cwd: Path, timeout: float = 120.0) -> tuple:
+    """`(status, transcript)`: `line` typed into `zsh -f -i` through a pty.
+
+    `-f` reads no startup file of the person's, so `interactivecomments` is
+    zsh's default, OFF, which is the shell #277 is about; `TERM=dumb` keeps
+    the line editor quiet. The line is typed whole, then a second line that
+    prints its status; `exit` is typed only once that answer is read, so a
+    platform that drops a pty's unread output when the shell ends cannot
+    lose it. `status` is None when no answer came -- a line that left the
+    shell inside an open quotation, say -- and the transcript says why.
+
+    The environment is the test's own, less `PYTHONPATH` (a NEXT carries
+    what it needs, #238) and with file-protocol git for the one child that
+    may clone from the suite's local remotes -- per process, never
+    `GIT_ALLOW_PROTOCOL` (see `tests/conftest.py`). It is read from
+    `os.environ` HERE, at the call, and is not doctor A's `PASTE_ENV`: that
+    dict is built when its module is imported, at collection, before the
+    session fixture puts the `gh` guard first on `PATH`, so a line pasted
+    with it would reach whatever `gh` the machine has.
+    """
+    import pty  # POSIX only: `tty` beneath it needs `termios`
+    env = {name: value for name, value in os.environ.items()
+           if name.upper() != "PYTHONPATH"}
+    env.update({"TERM": "dumb", "PYTHONDONTWRITEBYTECODE": "1",
+                "GIT_CONFIG_COUNT": "1",
+                "GIT_CONFIG_KEY_0": "protocol.file.allow",
+                "GIT_CONFIG_VALUE_0": "always"})
+    master, slave = pty.openpty()
+    try:
+        shell = subprocess.Popen(["zsh", "-f", "-i"], stdin=slave,
+                                 stdout=slave, stderr=slave, cwd=str(cwd),
+                                 env=env, start_new_session=True)
+    finally:
+        os.close(slave)
+    heard = bytearray()
+    deadline = time.monotonic() + timeout
+
+    def listen(until=None) -> re.Match | None:
+        while time.monotonic() < deadline:
+            if until is not None:
+                found = until.search(heard.decode("utf-8", "replace"))
+                if found:
+                    return found
+            ready, _, _ = select.select([master], [], [], 0.5)
+            if not ready:
+                if shell.poll() is not None:
+                    return None
+                continue
+            try:
+                chunk = os.read(master, 65536)
+            except OSError:  # EIO: Linux's EOF on a pty whose shell is gone
+                return None
+            if not chunk:
+                return None
+            heard.extend(chunk)
+        return None
+
+    try:
+        os.write(master, line.encode("utf-8") + b"\n"
+                 + b"print -r -- pasted-exit=$?\n")
+        answered = listen(PASTED_EXIT)
+        try:
+            os.write(master, b"exit\n")
+        except OSError:
+            pass
+        deadline = min(deadline, time.monotonic() + 10)
+        listen()
+    finally:
+        if shell.poll() is None:
+            shell.kill()
+        shell.wait(timeout=30)
+        os.close(master)
+    transcript = heard.decode("utf-8", "replace")
+    return (int(answered.group(1)) if answered else None), transcript
+
+
+#: What a pasted line must not have made the shell say: a word the shell
+#: tried to run (the text after a `;`), or an argument the command refused
+#: (the comment's own words, handed to it).
+MISREAD = ("command not found", "unrecognized arguments")
+
+
+@WINDOWS_SKIP
+@pytest.mark.skipif(shutil.which("zsh") is None, reason="needs zsh")
+def test_the_manifest_next_pasted_into_an_interactive_zsh_is_the_validator(
+        standard, project, holder, tmp_path):
+    """The validator's own finding, with the validator's own exit.
+
+    THE LINE MAIN PRINTED IS PASTED TOO, and is the defect: its validator
+    refuses the comment's words as arguments, `it names what it refused`
+    after the `;` is a command that does not exist, and the status the person
+    sees is that one's, 127. That half is what shows this harness reads `#`
+    the way the person's shell does; without it the first half could pass
+    in a shell that skipped the comment.
+    """
+    root = red_root("manifest", project, holder, tmp_path, keep_own=True)
+    row = rows_of(doctor(standard, root, "--json"))["manifest"]
+    assert row["status"] == "FINDING" and row["detail"]["own_copy"], row
+    here = tmp_path / "standing-anywhere"
+    here.mkdir()
+
+    status, transcript = paste_into_zsh(row["next"], here)
+    assert status == row["detail"]["exit"], transcript
+    assert "FINDING manifest-topic" in transcript, transcript
+    for misread in MISREAD:
+        assert misread not in transcript, (misread, transcript)
+
+    status, transcript = paste_into_zsh(f"{row['next']}   # {row['why']}",
+                                        here)
+    assert status == 127, transcript
+    assert "command not found: it" in transcript, transcript
+
+
+def legs_line_before_277(standard: Path, root: Path) -> str:
+    """The `legs` NEXT the doctor printed for `root` before #276 and #277
+    (`check_legs` at 3ae0109, the line #277 was filed against): the root's
+    own bootstrap, and a tail holding `make bootstrap` in backticks.
+
+    SPELLED HERE BECAUSE NOTHING PRINTS IT ANY MORE. #276 made the `legs`
+    NEXT a git line whose sentence carries no backtick, so the line it
+    prints today, with its `why` put back after `   # `, runs no `make`
+    pasted, and could not show that this harness runs a backtick at all.
+    """
+    module = doctor_module(standard)
+    return (f"{module.PYTHON} "
+            f"{module.quote_arg(root / 'scripts' / 'bootstrap.py')} "
+            f"--root {module.quote_arg(root)}   # what `make bootstrap` "
+            "runs: it puts every leg on its tracking branch AT the pinned "
+            "commit")
+
+
+@WINDOWS_SKIP
+@pytest.mark.skipif(shutil.which("zsh") is None or shutil.which("make") is None,
+                    reason="needs zsh and make")
+def test_the_legs_next_pasted_into_an_interactive_zsh_runs_no_make(
+        standard, project, tmp_path):
+    """Pasted where a Makefile's `bootstrap` target leaves a marker: none.
+
+    The `legs` comment said "what `make bootstrap` runs" -- a pair of
+    backticks, which an interactive zsh runs as command substitution in the
+    directory the person is standing in, before the command it was pasted
+    with. That line (`legs_line_before_277`) is pasted second, in the same
+    directory, and leaves the marker, so the first half cannot be passing
+    because the harness never runs a backtick.
+    """
+    commit_in(project / "spec")
+    row = rows_of(doctor(standard, project, "--json"))["legs"]
+    assert row["status"] == "FINDING", row
+    here = tmp_path / "standing-here"
+    here.mkdir()
+    (here / "Makefile").write_text("bootstrap:\n\ttouch MARKER\n",
+                                   encoding="utf-8")
+    marker = here / "MARKER"
+
+    status, transcript = paste_into_zsh(row["next"], here)
+    assert status is not None, transcript
+    assert not marker.exists(), transcript
+    for misread in MISREAD:
+        assert misread not in transcript, (misread, transcript)
+
+    paste_into_zsh(legs_line_before_277(standard, project.resolve()), here)
+    assert marker.exists(), (
+        "the line the doctor printed before #277 must run `make bootstrap` "
+        "here, or this test is proving nothing about the backticks")
+
+
+# --- the report says the sentence, off the command's line -------------------
+
+def test_the_table_prints_why_on_its_own_line_under_next(standard, project,
+                                                        holder, tmp_path):
+    """`NEXT` is the command as `--json` has it, and `WHY` is the line under
+    it, with the sentence `--json` carries as `why`. Two rows at once, so the
+    pairing is shown to be per row, and every row of the run carries the key.
+    """
+    root = red_root("manifest", project, holder, tmp_path, keep_own=True)
+    commit_in(root / "spec")
+    rows = rows_of(doctor(standard, root, "--json"))
+    for name, row in rows.items():
+        assert "why" in row, (name, row)
+    explained = [row for row in rows.values() if row["next"] and row["why"]]
+    assert {"manifest", "legs"} <= {row["id"] for row in explained}, rows
+    table = doctor(standard, root).stdout.splitlines()
+    for row in explained:
+        [at] = [index for index, line in enumerate(table)
+                if line.split()[:1] == ["NEXT"]
+                and line.endswith("  " + row["next"])]
+        assert table[at + 1].split()[0] == "WHY", table[at:at + 2]
+        assert table[at + 1].endswith("  " + row["why"]), table[at:at + 2]
+
+
+def test_a_report_that_cannot_answer_says_why_after_the_remediation(
+        standard, project, tmp_path):
+    """The CANNOT ANSWER block on stderr: `Remediation:` is the command, as
+    the row's `next` is, and `Why:` is the line after it."""
+    stranger = standard_of_another_history(standard, tmp_path)
+    row = rows_of(doctor(stranger, project, "--json"))["shape-currency"]
+    plain = doctor(stranger, project)
+    assert plain.returncode == 3, plain.stdout + plain.stderr
+    said = plain.stderr.splitlines()
+    [at] = [index for index, line in enumerate(said)
+            if line.startswith("  Remediation: ")]
+    assert said[at] == "  Remediation: " + row["next"], said
+    assert said[at + 1] == "  Why: " + row["why"], said
+
+
+def test_a_cannot_answer_row_with_no_command_still_says_why(
+        standard, project, capsys):
+    """`Why:` is printed whenever the row has a `why`, whether or not it has
+    a command for `Remediation:` (the coordinator's ruling on #277's merge
+    with #278, which prints no `Remediation:` for a row with no NEXT). No
+    row the doctor builds today is that row, so the report is handed one."""
+    module = doctor_module(standard)
+    ctx = module.Context(project.resolve())
+    row = module.Row("cannot", "cannot", module.FINDING, "it could not ask",
+                     None, {"environment": True}, why="what to do instead")
+    module.report(ctx, [row], "CANNOT ANSWER (cannot: it could not ask)", 3)
+    said = capsys.readouterr().err.splitlines()
+    at = said.index("REFUSED shape-doctor-cannot-answer: it could not ask")
+    assert said[at + 1:] == ["  Why: what to do instead"], said
+
+
+# --- the guard: no tail comes back -------------------------------------------
+
+#: What the guard calls a tail: two or more blanks, or a tab, then `#` and a
+#: blank. The house spelling was three spaces; two, or a tab, is the same
+#: comment to a shell, and the same word to an interactive zsh.
+TAIL = re.compile(r"(?:[ \t]{2,}|\t)#[ \t]")
+
+#: The strings that may hold one, by the def they are written in -- its
+#: whole path from the module, so a nested def or a method that shares the
+#: name is not waved through -- and why: neither is a NEXT. `None` allows
+#: every string in that def; text allows that one string and no other, so a
+#: tail written anywhere else in `report` is still found. A line number
+#: would move with every edit above it.
+TAIL_ALLOWED = {
+    # YAML comment lines, written into the placement plan.
+    "placement_plan_leg": None,
+    # `placement plan written to <file>   # nothing moved: ...`, a line of
+    # the report and not a command.
+    "report": "   # nothing moved: answer every `resolution:` before a repair "
+              "runs it",
+}
+
+
+def tails_in(source: str) -> list[tuple[int, str, str]]:
+    """`(line, def, text)` for every string constant in `source` that holds
+    a `TAIL` and is not a docstring, by the path of the defs it is written
+    in (`outer/inner`, or `<module>`).
+
+    The pieces of an f-string are constants too, so a tail spelled after a
+    `{command}` is found like any other.
+    """
+    tree = ast.parse(source)
+    docstrings = set()
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef,
+                             ast.AsyncFunctionDef)) and node.body:
+            first = node.body[0]
+            if isinstance(first, ast.Expr) and \
+                    isinstance(first.value, ast.Constant) and \
+                    isinstance(first.value.value, str):
+                docstrings.add(id(first.value))
+    found: list[tuple[int, str, str]] = []
+
+    def visit(node, owner: str) -> None:
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef,
+                                  ast.ClassDef)):
+                visit(child, child.name if owner == "<module>"
+                      else f"{owner}/{child.name}")
+                continue
+            if isinstance(child, ast.Constant) and \
+                    isinstance(child.value, str) and \
+                    id(child) not in docstrings and TAIL.search(child.value):
+                found.append((child.lineno, owner, child.value))
+            visit(child, owner)
+
+    visit(tree, "<module>")
+    return found
+
+
+def disallowed(found: list[tuple[int, str, str]]) -> list:
+    """The tails `TAIL_ALLOWED` does not allow."""
+    return [(line, owner, text) for line, owner, text in found
+            if owner not in TAIL_ALLOWED
+            or TAIL_ALLOWED[owner] not in (None, text)]
+
+
+def test_no_string_in_the_doctor_ends_a_command_with_a_comment():
+    """The CLASS of the defect, for every builder, including later ones.
+
+    Every NEXT is built from string constants in `shape-doctor.py`, so a
+    tail in one is on its way to a NEXT. Two places hold that text for
+    other reasons (`TAIL_ALLOWED`). A builder that wants to say why its
+    command is the fix says it as the row's `why`.
+
+    THE SCANNER IS SHOWN TO SEE ONE FIRST, on samples spelled the ways a
+    tail can be -- three spaces after an f-string's `{command}`, two spaces,
+    a tab, a second tail in `report` beside its allowed line, and one in a
+    nested def that shares the name `report` -- beside a docstring that
+    mentions one and must not count. And both allowed strings are found in
+    the real file, so the guard is reading the strings it should.
+    """
+    sample = ('def builder(command):\n'
+              '    """Its docstring may say `   # x`."""\n'
+              '    return f"{command}   # a tail"\n'
+              'def two(command):\n'
+              '    return command + "  # two spaces"\n'
+              'def tab(command):\n'
+              '    return command + "\\t# a tab"\n'
+              'def report(plan):\n'
+              f'    print(f"{{plan}}{TAIL_ALLOWED["report"]}")\n'
+              '    print(f"{plan}   # a second one")\n'
+              'def outer():\n'
+              '    def report():\n'
+              '        return "x   # nested"\n'
+              '    return report\n')
+    assert [(owner, text) for _, owner, text in
+            disallowed(tails_in(sample))] == [
+        ("builder", "   # a tail"), ("two", "  # two spaces"),
+        ("tab", "\t# a tab"), ("report", "   # a second one"),
+        ("outer/report", "x   # nested")]
+
+    found = tails_in((REPO / DOCTOR).read_text(encoding="utf-8"))
+    outside = disallowed(found)
+    assert not outside, (
+        f"{DOCTOR} builds a string with a `   # ` tail at {outside}; an "
+        "interactive zsh reads that `#` as a word and runs what follows it "
+        "(#277). Pass the sentence as the row's `why=` instead.")
+    assert {owner for _, owner, _ in found} == set(TAIL_ALLOWED), found
+    assert TAIL_ALLOWED["report"] in [text for _, owner, text in found
+                                      if owner == "report"], found
diff --git a/tests/test_doctor_validator_rows.py b/tests/test_doctor_validator_rows.py
index f6bec1ab..07dee634 100644
--- a/tests/test_doctor_validator_rows.py
+++ b/tests/test_doctor_validator_rows.py
@@ -18,8 +18,8 @@
   dies on the import instead.
 
 EVERY ASSERTION IS ON WHAT A COMMAND DOES -- the row's status, its `detail`,
-the verdict, and a NEXT that is run -- and never on a NEXT's `   # ` tail,
-whose text another change moves. The fixtures are those of
+the verdict, and a NEXT that is run -- and never on the words of a row's
+`why`, the sentence beside its NEXT (#277). The fixtures are those of
 `tests/test_shape_doctor.py`, imported, so the standard, the project and the
 holder are the ones every other doctor test reads.
 
@@ -108,10 +108,11 @@ def standard_under(standard: Path, tmp_path: Path, directory: str) -> Path:
 
 
 def command_of(row: dict) -> list:
-    """The row's NEXT as the argv it runs, its `   # ` tail cut off. The
-    paths in these tests need no quoting on either platform, which is what
-    lets the same list run on Windows, where no `sh` pastes it."""
-    return row["next"].split("   # ", 1)[0].split()
+    """The row's NEXT as the argv it runs: the whole of it, since a NEXT is
+    only the command (#277). The paths in these tests need no quoting on
+    either platform, which is what lets the same list run on Windows, where
+    no `sh` pastes it."""
+    return row["next"].split()
 
 
 def run_argv(command: list) -> subprocess.CompletedProcess:
@@ -183,12 +184,17 @@ def test_a_validator_that_crashed_says_so_and_never_reports_a_finding(
         expected = doctor_module(here).validator_command(
             shape, shape / TEMPLATE_FALLBACK["manifest"]["template"], False,
             ["--root", root])
-        assert row["next"].startswith(expected + "   # "), row["next"]
+        # THE NEXT IS THE LINE ALONE and what to do with its output is the
+        # row's `why` (#277).
+        assert row["next"] == expected, row["next"]
+        assert row["why"].startswith("read its output in full"), row
         # A ROW WITH A NEXT STILL PRINTS ITS REMEDIATION (the control of the
-        # colon row below, which has none and prints no `Remediation:`).
+        # colon row below, which has none and prints no `Remediation:`), and
+        # its `why` after it.
         stderr = doctor(here, root).stderr
         assert "REFUSED shape-doctor-cannot-answer: " in stderr, stderr
-        assert f"\n  Remediation: {row['next']}" in stderr, stderr
+        assert (f"\n  Remediation: {row['next']}\n  Why: {row['why']}"
+                in stderr), stderr
 
 
 @WINDOWS_SKIP
@@ -333,7 +339,7 @@ def test_a_standard_under_a_semicolon_is_refused_only_where_it_separates(
     assert "environment" not in row["detail"], row
     assert row["detail"]["exit"] == 1, row
     assert spec["finding"] in row["reason"], row
-    assert row["next"].startswith("PYTHONPATH='"), row["next"]
+    assert row["next"].startswith("env PYTHONPATH='"), row["next"]
     if shutil.which("sh") is not None:
         pasted = pasted_from_elsewhere(row["next"], tmp_path)
         whole = pasted.stdout + pasted.stderr
@@ -784,9 +790,9 @@ def test_a_colon_standard_withholds_the_legs_rows_lockstep_line(
     path is (#278).
 
     THE CONTROL is the same root asked from a plain directory, where the line
-    is printed and is the command the `pins` row hands over (the tails that
-    explain it differ), so the None below is the separator's doing and not a
-    fixture that never had a line.
+    is printed and is the command the `pins` row hands over (the `why`s
+    that explain it differ), so the None below is the separator's doing and
+    not a fixture that never had a line.
     `WINDOWS_SKIP`: Windows refuses `:` in a file name; the semicolon half of
     the helper is held by the semicolon test above.
     """
@@ -795,7 +801,7 @@ def test_a_colon_standard_withholds_the_legs_rows_lockstep_line(
     control = rows_of(doctor(standard, project, "--json"))
     plain = control["legs"]
     assert plain["status"] == "FINDING", plain
-    assert plain["next"].startswith("PYTHONPATH="), plain
+    assert plain["next"].startswith("env PYTHONPATH="), plain
     assert "validate-pins.py" in plain["next"], plain
     assert command_of(plain) == command_of(control["pins"]), (
         plain, control["pins"])
@@ -833,7 +839,7 @@ def test_a_colon_standard_withholds_the_members_rows_lockstep_line_too(
     control = rows_of(doctor(standard, root, "--json"))
     plain = control["members"]
     assert plain["status"] == "FINDING", plain
-    assert plain["next"].startswith("PYTHONPATH="), plain
+    assert plain["next"].startswith("env PYTHONPATH="), plain
     assert "validate-family.py" in plain["next"], plain
     assert command_of(plain) == command_of(control["family"]), (
         plain, control["family"])
diff --git a/tests/test_shape_doctor.py b/tests/test_shape_doctor.py
index e51fbc52..cf6e8fcb 100644
--- a/tests/test_shape_doctor.py
+++ b/tests/test_shape_doctor.py
@@ -223,7 +223,7 @@ def test_every_row_of_a_compliant_project_is_ok_or_na(standard, project):
         assert row["status"] in ("ok", "n/a"), (name, row)
         assert row["status"] != "FINDING", (name, row)
         assert set(row) == {"id", "label", "status", "reason", "next",
-                            "detail"}
+                            "why", "detail"}
     # The project carries its OWN validators, so those are what ran.
     assert rows["pins"]["detail"]["own_copy"] is True
     assert rows["manifest"]["detail"]["own_copy"] is True
@@ -287,6 +287,24 @@ def test_an_edited_shape_copy_is_drift_and_names_update_shape(standard,
 
 # --- the standard has moved on ---------------------------------------------
 
+def standard_ahead(standard: Path, tmp_path: Path, path: str = "README.md",
+                   appended: str = "\nA fix.\n",
+                   message: str = "An upstream change to a file no project "
+                                  "copies") -> Path:
+    """A COPY of the standard at `<tmp>/standard-ahead`, with one more commit
+    that appends `appended` to `path`. By default that is `README.md`, a file
+    no copy list names, so nothing a project holds can differ and the pin
+    alone is behind. One helper, because the tests here and the ones in
+    `tests/test_doctor_next_is_a_command.py` each built it by hand (#277)."""
+    ahead = tmp_path / "standard-ahead"
+    shutil.copytree(standard, ahead, symlinks=True)
+    target = ahead / path
+    target.write_text(target.read_text(encoding="utf-8") + appended,
+                      encoding="utf-8")
+    commit_all(ahead, message)
+    return ahead
+
+
 @pytest.fixture
 def advanced_standard(standard, tmp_path) -> Path:
     """A COPY of the standard with one more commit on a copied template.
@@ -296,14 +314,9 @@ def advanced_standard(standard, tmp_path) -> Path:
     `standard`, and advancing it in place would make them all say `SHAPE
     BEHIND` depending on the order they ran in.
     """
-    ahead = tmp_path / "standard-ahead"
-    shutil.copytree(standard, ahead, symlinks=True)
-    target = ahead / UPSTREAM_TARGET
-    target.write_text(target.read_text(encoding="utf-8")
-                      + "\n# an upstream fix, after this project was cut\n",
-                      encoding="utf-8")
-    commit_all(ahead, "An upstream fix to a copied file")
-    return ahead
+    return standard_ahead(standard, tmp_path, UPSTREAM_TARGET,
+                          "\n# an upstream fix, after this project was cut\n",
+                          "An upstream fix to a copied file")
 
 
 def test_a_project_behind_the_standard_is_compliant_but_behind(
@@ -1390,7 +1403,8 @@ def test_a_directory_that_is_not_a_repository_says_scaffold(standard,
     assert ("setup-project.py" if os.name == "nt" else "setup.sh") in \
         rows["way-in"]["next"], rows["way-in"]["next"]
     assert "--org <your-org>" in rows["way-in"]["next"]
-    assert "without --yes" in rows["way-in"]["next"]
+    # Said beside the command, never on it (#277).
+    assert "without --yes" in rows["way-in"]["why"]
     assert rows["way-in"]["detail"]["git_repository"] is False
     assert "an ordinary directory" in rows["contents"]["reason"]
 
@@ -1670,8 +1684,10 @@ def test_the_json_report_of_an_unloaded_manifest_is_the_same_report(
     assert manifest["detail"]["manifest"] == "project.yaml"
     assert manifest["detail"]["own_copy"] is True
     assert_next_runs_the_roots_own(manifest, project, "validate-manifest.py")
-    assert "the file to fix is" in manifest["next"], manifest["next"]
-    assert "project.yaml" in manifest["next"].split("#", 1)[1]
+    # The file to fix is named in the row's `why`, off the command's line
+    # (#277).
+    assert "the file to fix is" in manifest["why"], manifest["why"]
+    assert "project.yaml" in manifest["why"]
 
     for name in WAITING_ROWS:
         row = rows[name]
@@ -1794,7 +1810,8 @@ def test_a_family_yaml_that_does_not_load_is_invalid_and_not_absent(
     assert family["reason"] == \
         f"family.yaml does not load: {loader_line(refusal)}", family
     assert_next_runs_the_roots_own(family, root, "validate-family.py")
-    assert "family.yaml" in family["next"].split("#", 1)[1]
+    # Named in the row's `why`, off the command's line (#277).
+    assert "family.yaml" in family["why"], family["why"]
     members = rows["members"]
     assert members["status"] == "n/a", members
     assert members["detail"]["waits_on"] == "family", members
@@ -2198,13 +2215,8 @@ def test_a_pin_behind_with_no_file_differing_is_still_behind(standard,
     there too, because `apply` would move the pin alone. Reporting COMPLIANT
     would have made the verdict disagree with the sentence that defines it.
     """
-    ahead = tmp_path / "standard-ahead"
-    shutil.copytree(standard, ahead, symlinks=True)
     # A file no copy list names, so nothing a project holds can differ.
-    (ahead / "README.md").write_text(
-        (ahead / "README.md").read_text(encoding="utf-8") + "\nA fix.\n",
-        encoding="utf-8")
-    commit_all(ahead, "An upstream change to a file no project copies")
+    ahead = standard_ahead(standard, tmp_path)
     result = doctor(ahead, project, "--json")
     assert result.returncode == 1, result.stdout + result.stderr
     payload = json.loads(result.stdout)
@@ -2295,8 +2307,9 @@ def powershell_tokens(line: str) -> list[str]:
     Doe\\...'` -- and a test that split on whitespace tore that value in
     half and then failed a correct command. `#` has the same shape of
     answer: it opens a comment where a TOKEN starts and is an ordinary
-    character anywhere else, so a path with one in it survives and the
-    trailing `# and the rest are RENDERED...` the row appends does not.
+    character anywhere else, so a path with one in it survives and a
+    trailing `# and the rest are RENDERED...` does not. (The row appended
+    that note until #277 moved it to its `why`; `RENDERED_NOTE` keeps it.)
 
     Verbatim `'...'` only, because that is the one quoting `quote_arg`
     emits: nothing inside is expanded and an apostrophe is doubled.
@@ -2335,11 +2348,11 @@ def copied_paths(line: str, platform: str | None = None) -> tuple[str, str]:
     """The source and the target back out of the row's copy line.
 
     `shlex` on POSIX because that is the reader's own parser there --
-    `comments=True` so it drops the row's trailing `#` note the way the
-    shell would, rather than a naive `split("#")` cutting a path that has
-    one in it. On Windows the cmdlet's spelling, read by a parser that
-    knows PowerShell's verbatim string; `platform` so either branch can be
-    asserted from either host, as `copy_command` itself can be.
+    `comments=True` so it drops a trailing `#` note the way `sh` would,
+    rather than a naive `split("#")` cutting a path that has one in it. On
+    Windows the cmdlet's spelling, read by a parser that knows PowerShell's
+    verbatim string; `platform` so either branch can be asserted from either
+    host, as `copy_command` itself can be.
     """
     if (os.name if platform is None else platform) != "nt":
         parts = shlex.split(line, comments=True)
@@ -2363,7 +2376,8 @@ def test_a_missing_rendered_leg_file_is_not_offered_a_cp(standard, project):
     row = rows_of(doctor(standard, project, "--json"))["leg-shape-files"]
     assert row["status"] == "note"
     assert not row["next"].startswith(COPY_VERB), row["next"]
-    assert "RENDERED" in row["next"], row["next"]
+    # What the file IS is the row's `why`; the NEXT is a command (#277).
+    assert "RENDERED" in row["why"], row["why"]
 
     (project / "spec" / "CLAUDE.md").unlink()
     row = rows_of(doctor(standard, project, "--json"))["leg-shape-files"]
@@ -2456,9 +2470,9 @@ def test_the_copy_line_is_literal_where_cp_is_a_cmdlet(platform, source,
 #: A path that breaks a naive parser three ways at once -- a space, an
 #: apostrophe (doubled inside PowerShell's verbatim string, closed-escaped-
 #: reopened by `sh`'s) and a `#`, which opens a comment where a TOKEN starts
-#: and is an ordinary character anywhere else. The row appends a real
-#: trailing comment of its own when only some of the missing files are
-#: copyable, so a reader of these lines has to tell those two apart
+#: and is an ordinary character anywhere else. The row appended a real
+#: trailing comment of its own when only some of the missing files were
+#: copyable, so a reader of these lines had to tell those two apart
 #: (Copilot, PR #107). Each row is its own platform's spelling of a path,
 #: and both are asserted from whichever host runs the suite.
 AWKWARD_COPY = [
@@ -2468,10 +2482,12 @@ def test_the_copy_line_is_literal_where_cp_is_a_cmdlet(platform, source,
      "C:\\work #2\\O'Brien\\spec\\CLAUDE.md"),
 ]
 
-#: What `check_leg_shape_files` appends when some of the missing files are
-#: RENDERED per project and only the rest can be copied -- a real trailing
-#: comment on a real line, kept here verbatim so the parser above is proved
-#: against what the row actually prints.
+#: What `check_leg_shape_files` APPENDED, until #277, when some of the
+#: missing files are RENDERED per project and only the rest can be copied --
+#: a real trailing comment on a real line. The row now prints that sentence
+#: as its `why`, on a line of its own, and its NEXT is the copy alone; the
+#: note is kept here verbatim so the parser above is still proved to drop a
+#: comment without taking a `#` inside a quotation with it.
 RENDERED_NOTE = ("   # and the rest are RENDERED per project (placeholders): "
                  "scaffold-project.py writes those, and copying a template "
                  "verbatim would not")
@@ -2487,8 +2503,8 @@ def test_the_copy_line_is_read_back_by_the_quoting_it_was_written_with(
     space and then fails a command that was perfectly correct, and truncates
     a path with a `#` in it before the assertion is even made (Copilot, PR
     #107). Both shells' quoting is now read by something that knows it, and
-    the row's own trailing comment is dropped without taking a `#` that sits
-    inside a quotation with it.
+    a trailing comment is dropped without taking a `#` that sits inside a
+    quotation with it.
     """
     module = doctor_module(REPO)
     line = module.copy_command(source, target, platform) + RENDERED_NOTE
@@ -3589,12 +3605,7 @@ def test_shape_behind_names_the_pin_when_no_file_differs(standard, project,
     was a clause contradicting its own verdict — and it fired on both real
     estates on this machine, which makes it the common case.
     """
-    ahead = tmp_path / "standard-ahead"
-    shutil.copytree(standard, ahead, symlinks=True)
-    (ahead / "README.md").write_text(
-        (ahead / "README.md").read_text(encoding="utf-8") + "\nA fix.\n",
-        encoding="utf-8")
-    commit_all(ahead, "An upstream change to a file no project copies")
+    ahead = standard_ahead(standard, tmp_path)
     result = doctor(ahead, project, "--json")
     payload = json.loads(result.stdout)
     assert result.returncode == 1
@@ -3642,10 +3653,16 @@ def behind_row(standard, root, lane: str | None):
 def test_the_apply_a_behind_row_prints_carries_the_lane_when_one_is_set(
         advanced_standard, project):
     """The copied-file branch of the row: `--trailer` last, after
-    `--branch`, quoted whole so the paste survives the space in it."""
-    plain = behind_row(advanced_standard, project, None)["next"]
-    lane = behind_row(advanced_standard, project, LANE)["next"]
-    assert lane == plain + f" --trailer 'Lane: {LANE}'"
+    `--branch`, quoted whole so the paste survives the space in it.
+
+    THE `apply` IS THE ROW'S `why` since #277 -- the words that followed
+    `   # ` on its NEXT line -- and the trailer is read there. The NEXT, the
+    `check`, is the same line with or without a lane."""
+    plain = behind_row(advanced_standard, project, None)
+    laned = behind_row(advanced_standard, project, LANE)
+    assert laned["next"] == plain["next"]
+    lane = laned["why"]
+    assert lane == plain["why"] + f" --trailer 'Lane: {LANE}'"
     assert shlex.split(lane)[-2:] == ["--trailer", f"Lane: {LANE}"]
     assert "Co-Authored-By" not in lane, (
         "the second trailer names a person or a model, which no environment "
@@ -3656,16 +3673,12 @@ def test_the_behind_pin_only_row_carries_it_too(standard, project, tmp_path):
     """The other branch of the same row -- no copied file differs and the pin
     alone is behind -- because it spells its own apply and would otherwise be
     the one line in the report that forgot."""
-    ahead = tmp_path / "standard-ahead"
-    shutil.copytree(standard, ahead, symlinks=True)
-    (ahead / "README.md").write_text(
-        (ahead / "README.md").read_text(encoding="utf-8") + "\nA fix.\n",
-        encoding="utf-8")
-    commit_all(ahead, "An upstream change to a file no project copies")
+    ahead = standard_ahead(standard, tmp_path)
     row = behind_row(ahead, project, LANE)
     assert row["detail"]["behind_pin_only"] is True
-    assert row["next"].endswith(f" --trailer 'Lane: {LANE}'")
-    assert shlex.split(row["next"])[-2:] == ["--trailer", f"Lane: {LANE}"]
+    assert row["why"].endswith(f" --trailer 'Lane: {LANE}'")
+    assert shlex.split(row["why"])[-2:] == ["--trailer", f"Lane: {LANE}"]
+    assert "--trailer" not in row["next"], row["next"]
 
 
 def test_a_row_says_nothing_about_a_lane_when_none_is_set(advanced_standard,
@@ -3673,31 +3686,29 @@ def test_a_row_says_nothing_about_a_lane_when_none_is_set(advanced_standard,
     """Today's report, byte for byte, for everybody who is not in a lane."""
     row = behind_row(advanced_standard, project, None)
     assert "--trailer" not in row["next"]
-    assert row["next"].rstrip().endswith("--branch shape/update-"
-                                         + row["detail"]["standard"][:12])
+    assert "--trailer" not in row["why"]
+    assert row["why"].rstrip().endswith("--branch shape/update-"
+                                        + row["detail"]["standard"][:12])
 
 
 def test_no_other_row_grows_a_trailer(advanced_standard, project):
     """A `Lane:` trailer belongs on an `apply` and nowhere else: the row is
     naming the flag of a command that writes a commit, not decorating every
-    remediation in the table."""
+    remediation in the table. Read in `next` AND `why`, since the `apply`
+    moved to the second (#277)."""
     result = run_script(advanced_standard / DOCTOR, "--root", str(project),
                         "--json", env={"LANES_LANE": LANE})
     rows = rows_of(result)
     carrying = [name for name, row in rows.items()
-                if row["next"] and "--trailer" in row["next"]]
+                if "--trailer" in (row["next"] or "") + (row["why"] or "")]
     assert carrying == ["shape-currency"], rows
 
 
-def test_a_pin_this_standard_cannot_resolve_is_exit_three(standard, project,
-                                                          tmp_path):
-    """Not a verdict about the repository: this CHECKOUT cannot answer.
-
-    A pin naming a commit this standard does not carry — a fork, a branch
-    pin, a clone made before the commit landed — used to fall through to
-    `INVALID`, telling somebody their repository was wrong on the evidence
-    that our copy of the standard was short a commit.
-    """
+def standard_of_another_history(standard: Path, tmp_path: Path) -> Path:
+    """A standard that does not carry the commit a project's pin names: the
+    standard's files under a history of their own, so the `shape currency`
+    row is the CANNOT ANSWER one, exit 3. One helper, for the test below and
+    the ones in `tests/test_doctor_next_is_a_command.py` (#277)."""
     stranger = tmp_path / "stranger"
     stranger.mkdir()
     for name in ("contracts", "scripts", "templates"):
@@ -3707,6 +3718,19 @@ def test_a_pin_this_standard_cannot_resolve_is_exit_three(standard, project,
         shutil.copy2(standard / name, stranger / name)
     git("init", "-q", "-b", "main", ".", cwd=stranger)
     commit_all(stranger, "A standard with a history of its own")
+    return stranger
+
+
+def test_a_pin_this_standard_cannot_resolve_is_exit_three(standard, project,
+                                                          tmp_path):
+    """Not a verdict about the repository: this CHECKOUT cannot answer.
+
+    A pin naming a commit this standard does not carry — a fork, a branch
+    pin, a clone made before the commit landed — used to fall through to
+    `INVALID`, telling somebody their repository was wrong on the evidence
+    that our copy of the standard was short a commit.
+    """
+    stranger = standard_of_another_history(standard, tmp_path)
     result = doctor(stranger, project, "--json")
     assert result.returncode == 3, result.stdout + result.stderr
     payload = json.loads(result.stdout)
@@ -3807,14 +3831,22 @@ def break_the_pin(root: Path, mutation) -> None:
 def pasted(line: str) -> list[str]:
     """The argv the reader's own shell makes of a printed NEXT.
 
-    `shlex` on POSIX, over the command before the row's `   #` note, the way
+    `shlex` on POSIX, over the whole line, the way
     `test_a_red_validators_next_command_is_runnable` reads one; on Windows
-    PowerShell's reading, through `powershell_tokens`, which drops the note
-    itself and unquotes `quote_arg`'s verbatim strings.
+    PowerShell's reading, through `powershell_tokens`, which unquotes
+    `quote_arg`'s verbatim strings and, as PowerShell does, ends the line at
+    a `#` that opens a token.
+
+    THE WHOLE LINE ON POSIX, NOT THE PART BEFORE A `   #` (#277). The row's
+    sentence is its `why` and the NEXT is the command alone, so there is no
+    note to cut off. A reader that cut one off anyway would pass a NEXT that
+    had grown a tail back, and the argv assertions below would stop proving
+    the move. (`tests/test_doctor_next_is_a_command.py` holds the same NEXTs
+    to that on every OS.)
     """
     if os.name == "nt":
         return powershell_tokens(line)
-    return shlex.split(line.split("   #", 1)[0])
+    return shlex.split(line)
 
 
 def run_pasted(line: str) -> None:
@@ -3824,16 +3856,20 @@ def run_pasted(line: str) -> None:
     assert proc.returncode == 0, line + "\n" + proc.stdout + proc.stderr
 
 
-def assert_a_plain_note(line: str) -> None:
-    """The NEXT's `   #` note holds no `;`, apostrophe or backtick (#277).
+def assert_a_plain_next(row: dict) -> None:
+    """The NEXT is the command alone and the sentence is the row's `why`
+    (#277).
 
-    Pasted into an interactive zsh that does not take `#` as a comment, a
-    `;` starts a second command, an apostrophe opens a quotation nothing
-    closes and a backtick runs whatever follows it.
+    The sentence rode on the line as `   # <note>` until #277, and this
+    asserted the note held no `;`, apostrophe or backtick: pasted into an
+    interactive zsh that does not take `#` as a comment, a `;` starts a
+    second command, an apostrophe opens a quotation nothing closes and a
+    backtick runs whatever follows it. Nothing follows the command now, so
+    what is asserted is that none of the sentence is on the line, and that
+    it is said in `why`.
     """
-    note = line.split("   #", 1)[1]
-    for char in (";", "'", "`"):
-        assert char not in note, (char, line)
+    assert "   #" not in row["next"], row["next"]
+    assert row["why"], row
 
 
 def commit_in(root: Path, message: str, *args: str) -> str:
@@ -3890,7 +3926,7 @@ def test_a_root_pin_that_does_not_read_is_invalid_not_cannot_answer(
     assert pasted(row["next"])[:2] == ["git", "-C"], row["next"]
     assert "fetch" not in row["next"]
     assert "update-shape.py" not in row["next"]
-    assert_a_plain_note(row["next"])
+    assert_a_plain_next(row)
     plain = doctor(standard, project)
     assert plain.returncode == 1, plain.stdout + plain.stderr
     assert "CANNOT ANSWER" not in plain.stdout
@@ -4050,8 +4086,8 @@ def test_a_pin_broken_in_a_commit_is_put_back_from_before_that_commit(
     argv = pasted(row["next"])
     assert argv[:2] == ["git", "-C"], row["next"]
     assert argv[3:] == ["checkout", f"{breaking}~1", "--", SHAPE_PIN], argv
-    assert breaking[:12] in row["next"].split("   #", 1)[1], row["next"]
-    assert_a_plain_note(row["next"])
+    assert breaking[:12] in row["why"], row["why"]
+    assert_a_plain_next(row)
     run_pasted(row["next"])
     compliant_again(standard, project)
 
@@ -4100,11 +4136,11 @@ def test_the_issues_own_merge_takes_only_the_pin_whole(standard, project):
     argv = pasted(row["next"])
     assert argv[3:] == ["checkout", "--ours", "--", SHAPE_PIN], argv
     assert row["detail"]["left_for_a_person"] == ["Makefile"], row["detail"]
-    note = row["next"].split("   #", 1)[1]
+    note = row["why"]
     assert "Makefile is a copy conflicted too" in note, note
     assert "merges it by hand, keeping the hunks git merged" in note, note
-    assert "notes.md" not in row["next"], row["next"]
-    assert_a_plain_note(row["next"])
+    assert "notes.md" not in row["next"] and "notes.md" not in note, row
+    assert_a_plain_next(row)
     held = makefile.read_bytes()
     assert b"# edit-a" in held and b"# edit-b" in held, held[-200:]
     run_pasted(row["next"])
@@ -4152,10 +4188,10 @@ def test_a_readme_conflicted_over_the_projects_own_lines_is_left_to_a_person(
     assert pasted(row["next"])[3:] == [
         "checkout", "--ours", "--", SHAPE_PIN], row["next"]
     assert row["detail"]["left_for_a_person"] == ["README.md"], row["detail"]
-    note = row["next"].split("   #", 1)[1]
+    note = row["why"]
     assert "README.md is conflicted too" in note, note
     assert "a person merges it" in note, note
-    assert_a_plain_note(row["next"])
+    assert_a_plain_next(row)
     run_pasted(row["next"])
     assert b"only edit-a wrote" in readme.read_bytes(), \
         "edit-a's paragraph was dropped"
@@ -4235,10 +4271,10 @@ def test_the_issues_two_apply_merge_leaves_the_projects_manifest_to_a_person(
     assert row["detail"]["left_for_a_person"] == ["Makefile",
                                                   "project.yaml"], \
         row["detail"]
-    note = row["next"].split("   #", 1)[1]
+    note = row["why"]
     assert "project.yaml is conflicted too" in note, note
     assert "Makefile is a copy conflicted too" in note, note
-    assert_a_plain_note(row["next"])
+    assert_a_plain_next(row)
     held = (project / "Makefile").read_bytes()
     run_pasted(row["next"])
     assert b'name: "Atlas Renamed"' in manifest.read_bytes(), \
@@ -4325,8 +4361,8 @@ def test_a_merge_where_only_the_other_side_holds_a_pin_takes_theirs(
     assert row["detail"]["restore"] == "unmerged", row["detail"]
     assert pasted(row["next"])[3:] == [
         "checkout", "--theirs", "--", SHAPE_PIN], row["next"]
-    assert "only that side" in row["next"].split("   #", 1)[1]
-    assert_a_plain_note(row["next"])
+    assert "only that side" in row["why"], row["why"]
+    assert_a_plain_next(row)
     run_pasted(row["next"])
     again = rows_of(doctor(standard, project, "--json"))["shape-currency"]
     assert again["detail"]["error"] == "update-revision-unresolvable", again
@@ -4351,8 +4387,8 @@ def test_two_commits_that_each_broke_the_pin_are_reached_past(standard,
     assert row["detail"]["restore"] == "committed", row["detail"]
     assert pasted(row["next"])[3:] == [
         "checkout", f"{first}~1", "--", SHAPE_PIN], row["next"]
-    assert first[:12] in row["next"].split("   #", 1)[1], row["next"]
-    assert_a_plain_note(row["next"])
+    assert first[:12] in row["why"], row["why"]
+    assert_a_plain_next(row)
     run_pasted(row["next"])
     compliant_again(standard, project)
 
@@ -4400,7 +4436,7 @@ def assert_hidden(standard: Path, root: Path, code: str, letter: str) -> None:
     argv = pasted(row["next"])
     assert argv[3:] == ["ls-files", "-v", "--", SHAPE_PIN], row["next"]
     assert "checkout" not in argv, row["next"]
-    assert_a_plain_note(row["next"])
+    assert_a_plain_next(row)
     shown = subprocess.run(argv, capture_output=True, text=True, check=False)
     assert shown.returncode == 0, shown.stderr
     assert shown.stdout == f"{letter} {SHAPE_PIN}\n", shown.stdout
@@ -4478,7 +4514,7 @@ def test_a_pin_with_no_good_copy_in_its_history_keeps_the_check_next(
     assert "update-shape.py" in row["next"] and " check " in row["next"]
     assert "checkout" not in row["next"], row["next"]
     assert "fetch" not in row["next"]
-    assert_a_plain_note(row["next"])
+    assert_a_plain_next(row)
 
 
 def test_the_doctor_writes_no_bytecode_into_the_standard(standard, project,
@@ -4586,7 +4622,7 @@ def assert_no_registration(row: dict) -> None:
     for words in ("register the kind", "remove the file",
                   "MANIFEST_VALIDATORS"):
         assert words not in row["next"], (words, row["next"])
-    assert_a_plain_note(row["next"])
+    assert_a_plain_next(row)
 
 
 def shape_pin_conflicted(root: Path) -> list:
@@ -4700,7 +4736,7 @@ def test_a_file_a_tool_wrote_that_does_not_load_is_put_back_from_git(
     argv = pasted(row["next"])
     assert argv[:2] == ["git", "-C"], row["next"]
     assert argv[3:] == expected, argv
-    note = row["next"].split("   #", 1)[1]
+    note = row["why"]
     assert NOTE_SAYS[restore].format(what=what) in note, note
     assert "README.md" not in note and "a person merges" not in note, note
     if rel == SHAPE_PIN:
@@ -4834,7 +4870,7 @@ def test_a_file_git_cannot_put_back_is_left_to_a_person(standard, project,
     assert argv[0] == repo_shape.PYTHON, argv
     assert Path(argv[1]).name == DOCTOR and argv[2] == "--root", argv
     assert Path(argv[3]).resolve() == project.resolve(), argv
-    assert "for a person to decide" in row["next"].split("   #", 1)[1]
+    assert "for a person to decide" in row["why"], row
     before = (project / rel).read_bytes()
     proc = subprocess.run(argv, capture_output=True, text=True, check=False,
                           stdin=subprocess.DEVNULL,
@@ -5011,7 +5047,7 @@ def test_an_uncommitted_change_to_a_copy_is_shown_and_kept(standard,
     assert pasted(row["next"])[3:] == ["diff", "HEAD", "--", NAMING_COPY], \
         row["next"]
     assert "checkout" not in row["next"], row["next"]
-    assert "nothing is put back" in row["next"].split("   #", 1)[1]
+    assert "nothing is put back" in row["why"], row
     run_pasted(row["next"])
     assert copy.read_bytes() == before
     again = rows_of(doctor(standard, project, "--json"))["manifest-kinds"]
@@ -5204,7 +5240,7 @@ def test_a_copy_conflicted_on_its_own_is_shown_and_merged_by_a_person(
     assert_no_registration(row)
     assert pasted(row["next"])[3:] == ["diff", "--", NAMING_COPY], \
         row["next"]
-    note = row["next"].split("   #", 1)[1]
+    note = row["why"]
     assert "neither side is taken whole" in note, note
     assert "merge it by hand, keeping the hunks git merged" in note, note
     shown = run_read_only(standard, project, row)
@@ -5234,9 +5270,9 @@ def test_a_conflicted_copys_next_agrees_with_shape_currency_and_agents_md(
     """
     a_copy_conflicted_on_its_own(project)
     kinds, currency = kinds_and_currency(standard, project)
-    assert "merge it by hand" in kinds["next"].split("   #", 1)[1], kinds
+    assert "merge it by hand" in kinds["why"], kinds
     assert "checkout" not in kinds["next"], kinds["next"]
-    assert f"--accept-local {NAMING_COPY}" in currency["next"], currency
+    assert f"--accept-local {NAMING_COPY}" in currency["why"], currency
     merge_by_hand(project / NAMING_COPY)
     git("add", "--", NAMING_COPY, cwd=project)
     commit_in(project, "the naming copy merged by hand")
@@ -5245,7 +5281,7 @@ def test_a_conflicted_copys_next_agrees_with_shape_currency_and_agents_md(
     argv = pasted(currency["next"])
     assert Path(argv[1]).name == "update-shape.py" and argv[2] == "check", \
         currency["next"]
-    then = currency["next"].split("   #", 1)[1].split()
+    then = currency["why"].split()
     assert then[:2] == ["then", "apply"], currency["next"]
     assert then[then.index("--accept-local") + 1] == NAMING_COPY, then
     applied = run_script(standard / "update-shape.py", "apply", "--root",
@@ -5421,7 +5457,7 @@ def test_a_committed_hand_merge_of_a_copy_is_shown_not_rolled_back(
     assert_no_registration(row)
     assert pasted(row["next"])[3:] == ["diff", f"{breaking}~1", "--",
                                        NAMING_COPY], row["next"]
-    note = row["next"].split("   #", 1)[1]
+    note = row["why"]
     assert breaking[:12] in note and "nothing is rolled back" in note, note
     shown = run_read_only(standard, project, row)
     assert PROJECT_LINE.strip() in shown and SLIP.strip() in shown, shown
@@ -5495,12 +5531,12 @@ def test_a_neutral_product_pin_is_shown_never_put_back(standard, project,
     assert_no_registration(row)
     assert pasted(row["next"])[3:] == expected, row["next"]
     assert "No tool of this standard writes a neutral product pin" in \
-        row["next"].split("   #", 1)[1], row["next"]
+        row["why"], row
     # One `so` to a sentence (review of PR #358): the reason ended in its own
     # ", so every change to one was made by a person", and the note's ", so
     # neither side is taken whole" or ", so nothing is rolled back" followed.
     assert not any(sentence.count(", so ") > 1 for sentence in
-                   row["next"].split("   #", 1)[1].split(". ")), row["next"]
+                   row["why"].split(". ")), row["why"]
     run_read_only(standard, project, row)
     assert (project / NEUTRAL_PIN).read_bytes() == before
     assert b"2" * 40 in before
@@ -5619,8 +5655,9 @@ def assert_the_pin_alone_is_taken(currency: dict, kinds: dict,
         "checkout", "--ours", "--", SHAPE_PIN], currency["next"]
     assert currency["detail"]["left_for_a_person"] == [copy], currency
     assert kinds["next"] == currency["next"], (kinds, currency)
+    assert kinds["why"] == currency["why"], (kinds, currency)
     assert kinds["detail"]["left_for_a_person"] == [copy], kinds["detail"]
-    note = currency["next"].split("   #", 1)[1]
+    note = currency["why"]
     assert f"{copy} is a copy conflicted too" in note, note
     assert "merges it by hand, keeping the hunks git merged" in note, note
     assert "Take one side of the pin whole and never a hand-merged pin" \
@@ -5633,7 +5670,7 @@ def assert_the_pin_alone_is_taken(currency: dict, kinds: dict,
                   "refused as update-conflict and asks for --accept-local "
                   "on that path"):
         assert words in note, (words, note)
-    assert_a_plain_note(currency["next"])
+    assert_a_plain_next(currency)
 
 
 def re_pinned_from_the_merge(moved: Path, root: Path, currency: dict,
@@ -5650,7 +5687,7 @@ def re_pinned_from_the_merge(moved: Path, root: Path, currency: dict,
     `--accept-local` on that path. Either way that `apply --accept-local
     <copy>` re-pins the copy from the merge and the root is COMPLIANT.
     """
-    then = currency["next"].split("   #", 1)[1].split()
+    then = currency["why"].split()
     assert then[:2] == ["then", "apply"], currency["next"]
     args = then[2:]
     apply = (moved / "update-shape.py", "apply", "--root", str(root),
@@ -7974,9 +8011,9 @@ def test_the_way_in_row_matches_the_host_platform_end_to_end(standard,
     here.mkdir()
     (here / "notes.txt").write_text("nothing to see\n", encoding="utf-8")
     scaffolds = module.check_the_way_in(module.Context(here))
-    assert scaffolds.next_command == (
-        module.scaffold_command(module.SHAPE_ROOT, "Loose", os.name)
-        + "   # without --yes; it asks"), scaffolds.next_command
+    assert scaffolds.next_command == module.scaffold_command(
+        module.SHAPE_ROOT, "Loose", os.name), scaffolds.next_command
+    assert scaffolds.why == "without --yes; it asks", scaffolds.why
     # The other way in, from the same directory once it is a repository.
     git("init", "-q", "-b", "main", ".", cwd=here)
     adopts = module.check_the_way_in(module.Context(here))
@@ -8613,8 +8650,8 @@ def pasted_from_elsewhere(command: str, tmp_path: Path):
     The three things a reader's shell can have that the doctor's child did
     not: a different working directory (the line names every path absolutely,
     so it needs none), a different environment (this is the one under test),
-    and the whole line -- trailing `#` comment and all -- rather than an argv
-    the test split. `PYTHONDONTWRITEBYTECODE` is the one thing put back, so
+    and the whole line, exactly as printed, rather than an argv the test
+    split. `PYTHONDONTWRITEBYTECODE` is the one thing put back, so
     that running the standard's validators from the session's `standard`
     leaves no `__pycache__` in it, as every other paste here does.
     """
@@ -8666,9 +8703,12 @@ def test_a_template_validators_next_command_runs_when_it_is_pasted(
     # is the traceback, exit 1, and says nothing about the project.
     scripts = doctor_module(standard).quote_arg(standard.resolve() / "scripts",
                                                 "posix")
-    assert row["next"].startswith(f"PYTHONPATH={scripts} python3 "), row["next"]
+    # `env`, not a bare `NAME=value` prefix, which csh and tcsh cannot run
+    # (#277).
+    assert row["next"].startswith(f"env PYTHONPATH={scripts} python3 "), \
+        row["next"]
     bare = pasted_from_elsewhere(
-        row["next"].removeprefix(f"PYTHONPATH={scripts} "), tmp_path)
+        row["next"].removeprefix(f"env PYTHONPATH={scripts} "), tmp_path)
     assert bare.returncode == 1, bare.stdout + bare.stderr
     assert "ModuleNotFoundError: No module named 'repo_shape'" in \
         bare.stdout + bare.stderr, bare.stdout + bare.stderr
@@ -8696,9 +8736,9 @@ def test_a_template_validators_next_runs_when_pasted_into_powershell(
 
     TWO THINGS ABOUT `-Command`. A native command's non-zero exit is
     `$LASTEXITCODE`, and `-Command` ends the session with 1 whatever it was,
-    so `; exit $LASTEXITCODE` is appended -- to the COMMAND, with the row's
-    trailing `   # ...` comment cut off first, because PowerShell reads a
-    comment to the end of the line and would swallow the `exit` with it. And
+    so `; exit $LASTEXITCODE` is appended to the line as printed -- which is
+    the command alone since #277, with no trailing `#` comment to swallow
+    the `exit` the way PowerShell reads one, to the end of the line. And
     the output is read as BYTES and decoded here as UTF-8 with replacement,
     on purpose: the finding id this asserts is ASCII, and what the console's
     code page does to anything else is not under test. Nothing is fed to
@@ -8713,7 +8753,7 @@ def test_a_template_validators_next_runs_when_pasted_into_powershell(
     assert row["status"] == "FINDING", row
     assert row["detail"]["own_copy"] is False, row
     assert row["next"].startswith("$env:PYTHONPATH = '"), row["next"]
-    line = row["next"].split("   # ", 1)[0]
+    line = row["next"]
     env = {name: value for name, value in os.environ.items()
            if name.upper() != "PYTHONPATH"}
     env["PYTHONDONTWRITEBYTECODE"] = "1"
@@ -8748,11 +8788,11 @@ def test_a_template_validators_row_carries_the_same_next_in_text_and_json(
     expected = module.validator_command(shape, shape / spec["template"],
                                         False, ["--root", root])
     assert expected.startswith("$env:PYTHONPATH = " if os.name == "nt"
-                               else "PYTHONPATH="), expected
-    assert row["next"].startswith(expected + "   # "), (expected, row["next"])
+                               else "env PYTHONPATH="), expected
+    # THE COMMAND ALONE, and what to do with its output beside it (#277).
+    assert row["next"] == expected, (expected, row["next"])
     assert row["next"] in doctor(standard, root).stdout
-    assert row["next"].split("#", 1)[1].strip().startswith(
-        "read its output in full"), row["next"]
+    assert row["why"].startswith("read its output in full"), row["why"]
 
 
 @pytest.mark.parametrize("case", sorted(TEMPLATE_FALLBACK))
@@ -8775,8 +8815,9 @@ def test_a_roots_own_validators_next_command_is_unchanged(
     module = doctor_module(standard)
     assert row["next"] == (
         f"{module.PYTHON} {module.quote_arg(root / spec['own'])} --root "
-        f"{module.quote_arg(root)}   # read its output in full; it names "
-        "what it refused"), row["next"]
+        f"{module.quote_arg(root)}"), row["next"]
+    # The sentence that rode on the line as `   # ...` until #277.
+    assert row["why"] == "read its output in full; it names what it refused"
     assert "PYTHONPATH" not in row["next"], row["next"]
     assert_next_runs_the_roots_own(row, root, Path(spec["own"]).name)
 
@@ -9129,7 +9170,7 @@ def test_an_unloaded_manifests_template_next_command_runs_when_it_is_pasted(
     assert Path(row["detail"]["validator"]).name == script, row
     assert Path(row["detail"]["validator"]).resolve() != \
         (root / own).resolve(), row
-    assert row["next"].startswith("PYTHONPATH="), row["next"]
+    assert row["next"].startswith("env PYTHONPATH="), row["next"]
 
     pasted = pasted_from_elsewhere(row["next"], tmp_path)
     whole = pasted.stdout + pasted.stderr
@@ -9145,7 +9186,8 @@ def test_an_unloaded_manifests_own_copy_next_command_is_unchanged(
         standard, project, holder, tmp_path, kind, case):
     """The same row, the root's own copy present: no environment, and the
     line is what #205 printed -- the interpreter, the root's own validator
-    as a path, `--root` the root, and the comment that names the file to fix.
+    as a path, `--root` the root -- with the sentence that names the file to
+    fix as the row's `why`, where #277 moved the comment that used to end it.
     """
     if kind == "family":
         root = tmp_path / FAMILY_NAME
@@ -9163,11 +9205,12 @@ def test_an_unloaded_manifests_own_copy_next_command_is_unchanged(
     row = rows_of(doctor(standard, root, "--json"))[row_id]
     assert row["detail"]["own_copy"] is True, row
     module = doctor_module(standard)
-    assert row["next"].startswith(
+    assert row["next"] == (
         f"{module.PYTHON} {module.quote_arg(root / own)} --root "
-        f"{module.quote_arg(root)}   # the file to fix is "
-        f"{module.quote_arg(root / name)}, where the line above says; "), \
-        row["next"]
+        f"{module.quote_arg(root)}"), row["next"]
+    assert row["why"].startswith(
+        f"the file to fix is {module.quote_arg(root / name)}, where the line "
+        "above says; "), row["why"]
     assert "PYTHONPATH" not in row["next"], row["next"]
 
 
@@ -9178,10 +9221,12 @@ def test_an_unloaded_manifests_own_copy_next_command_is_unchanged(
 #: before it for PowerShell -- and what each does to a path that needs quoting.
 VALIDATOR_TEMPLATE = "templates/assembly-root/scripts/validate-manifest.py"
 VALIDATOR_COMMAND = [
-    # `sh`: `NAME=value command ...`, and a root's own copy has none.
+    # `sh`: `env NAME=value command ...` -- `env`, which csh, tcsh and fish
+    # run too, where a bare `NAME=value` prefix is `sh` syntax (#277) -- and
+    # a root's own copy has none.
     ("posix", PurePosixPath("/srv/openRepoShape"), False, PurePosixPath(
         "/srv/work/Atlas"),
-     "PYTHONPATH=/srv/openRepoShape/scripts python3 "
+     "env PYTHONPATH=/srv/openRepoShape/scripts python3 "
      "/srv/openRepoShape/templates/assembly-root/scripts/validate-manifest.py "
      "--root /srv/work/Atlas"),
     ("posix", PurePosixPath("/srv/openRepoShape"), True, PurePosixPath(
@@ -9192,7 +9237,7 @@ def test_an_unloaded_manifests_own_copy_next_command_is_unchanged(
     # and the assignment's quote closes at the value's end.
     ("posix", PurePosixPath("/srv/my shape"), False, PurePosixPath(
         "/srv/work/Atlas"),
-     "PYTHONPATH='/srv/my shape/scripts' python3 "
+     "env PYTHONPATH='/srv/my shape/scripts' python3 "
      "'/srv/my shape/templates/assembly-root/scripts/validate-manifest.py' "
      "--root /srv/work/Atlas"),
     # PowerShell: `$env:NAME = 'value'; command ...`, the value ALWAYS quoted.
@@ -9217,7 +9262,7 @@ def test_an_unloaded_manifests_own_copy_next_command_is_unchanged(
     # path on `sh` is quoted whole, every `\` a literal character.
     ("posix", PureWindowsPath(r"C:\srv\openRepoShape"), False,
      PureWindowsPath(r"C:\work\Atlas"),
-     r"PYTHONPATH='C:\srv\openRepoShape\scripts' python3 "
+     r"env PYTHONPATH='C:\srv\openRepoShape\scripts' python3 "
      r"'C:\srv\openRepoShape\templates\assembly-root\scripts"
      r"\validate-manifest.py' --root 'C:\work\Atlas'"),
 ]
@@ -9244,8 +9289,9 @@ def test_the_posix_validator_line_is_read_back_whole_by_sh_quoting():
     """A standard at an awkward path arrives as one value, apostrophe and all.
 
     `shlex.split` is the reader's own shell for the `sh` dialect, as it is
-    for every other line asserted that way here: the first word is the
-    assignment whole, the next the interpreter, the next the template.
+    for every other line asserted that way here: the first word is `env`
+    (#277), the next the assignment whole, the next the interpreter, the
+    next the template.
     """
     module = doctor_module(REPO)
     shape = PurePosixPath("/srv/Jane O'Neill/open Repo Shape")
@@ -9253,6 +9299,7 @@ def test_the_posix_validator_line_is_read_back_whole_by_sh_quoting():
         shape, shape / VALIDATOR_TEMPLATE, False,
         ["--root", PurePosixPath("/srv/work dir/Atlas")], "posix")
     assert shlex.split(line) == [
+        "env",
         "PYTHONPATH=/srv/Jane O'Neill/open Repo Shape/scripts", "python3",
         f"/srv/Jane O'Neill/open Repo Shape/{VALIDATOR_TEMPLATE}", "--root",
         "/srv/work dir/Atlas"], line
@@ -9511,12 +9558,7 @@ def test_the_pin_alone_clause_and_the_readme_note_never_say_opposite_things(
     precisely the case it is made most often.
     """
     pinned = git("rev-parse", "HEAD", cwd=standard).stdout.strip()
-    ahead = tmp_path / "standard-ahead"
-    shutil.copytree(standard, ahead, symlinks=True)
-    (ahead / "README.md").write_text(
-        (ahead / "README.md").read_text(encoding="utf-8") + "\nA fix.\n",
-        encoding="utf-8")
-    commit_all(ahead, "An upstream change to a file no project copies")
+    ahead = standard_ahead(standard, tmp_path)
     target = git("rev-parse", "HEAD", cwd=ahead).stdout.strip()
     assert pinned != target, "fixture: the standard has moved past the pin"
 
diff --git a/tests/test_update_shape_next_quoting.py b/tests/test_update_shape_next_quoting.py
index 98fb6b80..54753b05 100644
--- a/tests/test_update_shape_next_quoting.py
+++ b/tests/test_update_shape_next_quoting.py
@@ -489,7 +489,7 @@ def test_the_doctors_shape_currency_row_keeps_the_root_whole(project,
                                                              make_root, name):
     """THE HALF OF #325 THAT WAS ALREADY RIGHT. The doctor spells every value
     in this row with `quote_arg` (#101, #102), so its `check` and the `apply`
-    in its comment carry the same words the NEXT line above does. Asserted
+    in its `why` carry the same words the NEXT line above does. Asserted
     here for the roots #325 names, and for `$`, which the earlier tests of
     this row did not use."""
     root = make_root(name)
@@ -500,7 +500,11 @@ def test_the_doctors_shape_currency_row_keeps_the_root_whole(project,
     row = {r["id"]: r for r in json.loads(result.stdout)["rows"]}[
         "shape-currency"]
     assert row["status"] == "FINDING", row
-    command, _, then = row["next"].partition("   # then ")
+    # The `check` is the NEXT, alone, and the `apply` that follows it is the
+    # row's `why`, which opens with `then ` (#277).
+    command = row["next"]
+    assert row["why"].startswith("then "), row["why"]
+    then = row["why"].removeprefix("then ")
     assert shlex.split(command) == [
         PYTHON, str(upstream / "update-shape.py"), "check", "--root",
         str(root.resolve()), "--upstream", str(upstream)]