@@ -99,4 +99,111 @@ func TestWrapUsage_ANarrowWidthGivesTextTheWholeLine(t *testing.T) {
 	}
 }
 
+// TestWrapLong_ProseReflowsToTheWidth is #759's premise: a paragraph an author wrapped at 80 reflows to the
+// terminal, at 60 and at 100 alike, with no line over the width.
+func TestWrapLong_ProseReflowsToTheWidth(t *testing.T) {
+
+	const long = "Report deployed state: what should be present, where it should have come from, and\n" +
+		"what's missing or different.\n" +
+		"\n" +
+		"The report is derived from the store (the run index plus the persisted graphs and\n" +
+		"traces) -- never from a directory scan -- and has four sections: the registered layer\n" +
+		"tree, the deployed inventory classified against the live filesystem, the package\n" +
+		"operations writ's runs performed, and store health."
+
+	for _, width := range []int{60, 100} {
+		got := strings.Split(wrapLong(long, width), "\n")
+		for i, l := range got {
+			if len([]rune(l)) > width {
+				t.Errorf("width %d: line %d is %d columns: %q", width, i, len([]rune(l)), l)
+			}
+		}
+		blank := 0
+		for _, l := range got {
+			if l == "" {
+				blank++
+			}
+		}
+		if blank != 1 {
+			t.Errorf("width %d: %d blank lines, want the one that separates the paragraphs:\n%s", width, blank, strings.Join(got, "\n"))
+		}
+	}
+	// The author broke the first line at 82 columns; at 100 the paragraph packs past it.
+	if first := strings.SplitN(wrapLong(long, 100), "\n", 2)[0]; len([]rune(first)) <= 82 {
+		t.Errorf("at 100 the first paragraph did not reflow past the authored break: %q", first)
+	}
+}
+
+// TestWrapLong_StructureKeepsItsBreaks is why #755 left `Long` alone: a policy ladder is one entry per line, and
+// stays so at any width, indent intact.
+func TestWrapLong_StructureKeepsItsBreaks(t *testing.T) {
+
+	const long = "What each outcome does to the exit status is the signing policy ladder:\n" +
+		"\n" +
+		"  ignore           No verification at all\n" +
+		"  report           (default) Report every outcome; never fail\n" +
+		"  reject           Reject anything that is not valid"
+
+	got := strings.Split(wrapLong(long, 100), "\n")
+	want := strings.Split(long, "\n")
+	if len(got) != len(want) {
+		t.Fatalf("got %d lines, want %d:\n%s", len(got), len(want), strings.Join(got, "\n"))
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Errorf("line %d changed:\n got %q\nwant %q", i, got[i], want[i])
+		}
+	}
+}
+
+// TestWrapLong_AnOverLongStructureLineHangsUnderItsColumn: a table row too wide for the terminal wraps as a
+// usage line does, its continuation under the sentence, not under the name.
+func TestWrapLong_AnOverLongStructureLineHangsUnderItsColumn(t *testing.T) {
+
+	const long = "  modified-or-stale  Differs, but the run predates recorded content identity: attribution indeterminate"
+
+	got := strings.Split(wrapLong(long, 60), "\n")
+	if len(got) < 2 {
+		t.Fatalf("did not wrap at 60: %q", got)
+	}
+	for i, l := range got {
+		if len([]rune(l)) > 60 {
+			t.Errorf("line %d is %d columns: %q", i, len([]rune(l)), l)
+		}
+	}
+	if !strings.HasPrefix(got[1], strings.Repeat(" ", 21)) || strings.HasPrefix(got[1], strings.Repeat(" ", 22)) {
+		t.Errorf("continuation does not hang under the sentence column (21): %q", got[1])
+	}
+}
+
+// TestWrapLong_ZeroWidthIsUntouched mirrors pflag's meaning of zero: no wrapping at all.
+func TestWrapLong_ZeroWidthIsUntouched(t *testing.T) {
+
+	const long = "a line the author wrapped\nand its continuation"
+	if got := wrapLong(long, 0); got != long {
+		t.Errorf("width 0 changed the text: %q", got)
+	}
+}
+
+// TestWrapLong_MeasuresRunes: a multi-byte character counts as one column, so the wrap lands where it looks.
+func TestWrapLong_MeasuresRunes(t *testing.T) {
+
+	long := strings.Repeat("é ", 25) + "fin"
+	for i, l := range strings.Split(wrapLong(long, 20), "\n") {
+		if len([]rune(l)) > 20 {
+			t.Errorf("line %d is %d columns: %q", i, len([]rune(l)), l)
+		}
+	}
+}
+
+// TestWrapLong_TrailingWhitespaceGoes: every line is right-trimmed, so nothing an author left survives.
+func TestWrapLong_TrailingWhitespaceGoes(t *testing.T) {
+
+	for _, l := range strings.Split(wrapLong("prose with a trailing space \n  structure too \n", 80), "\n") {
+		if strings.TrimRight(l, " ") != l {
+			t.Errorf("trailing whitespace survived: %q", l)
+		}
+	}
+}
+
 // endregion
@@ -201,11 +201,13 @@ func initRootConfig(cmd *cobra.Command, name string) error {
 // leading indent and gives the text the whole width instead.
 const helpMinimumTextWidth = 24
 
-// wrapHelp makes flag usage wrap to the terminal, keeping any column structure the usage text has.
+// wrapHelp makes flag usage and a command's `Long` wrap to the terminal, keeping any structure the text has.
 //
 // Cobra's default template calls [pflag.FlagSet.FlagUsages], which is `FlagUsagesWrapped(0)`, and zero means
 // no wrapping at all -- so without this every line's width is the author's to maintain by hand, correct only
-// on a terminal at least as wide as the constant they guessed (#755).
+// on a terminal at least as wide as the constant they guessed (#755). Its help template prints `Long` verbatim
+// the same way (#759); [wrapLong] reflows it under one convention: an unindented line is prose and reflows
+// with its neighbors, an indented line is structure and keeps its break.
 //
 // pflag's own wrapping is not the answer either. It indents every continuation to the flag's description
 // column, having one indent level and no notion of structure, so a two-column usage -- `--output`'s ten
@@ -228,6 +230,14 @@ func wrapHelp(cmd *cobra.Command) {
 	template = strings.ReplaceAll(template, ".LocalFlags.FlagUsages", "wrappedFlagUsages .LocalFlags")
 	template = strings.ReplaceAll(template, ".InheritedFlags.FlagUsages", "wrappedFlagUsages .InheritedFlags")
 	cmd.SetUsageTemplate(template)
+
+	cobra.AddTemplateFunc("wrappedLong", func(long string) string {
+		return wrapLong(long, displayWidth())
+	})
+
+	help := cmd.HelpTemplate()
+	help = strings.ReplaceAll(help, "{{. | trimTrailingWhitespaces}}", "{{. | wrappedLong | trimTrailingWhitespaces}}")
+	cmd.SetHelpTemplate(help)
 }
 
 // wrapUsage wraps pflag's laid-out usage block to width, line by line.
@@ -333,4 +343,82 @@ func usageTextColumn(line string) int {
 	return leading
 }
 
+// wrapLong reflows a command's `Long` to width under the help convention (#759).
+//
+// A `Long` is blocks separated by blank lines. Within a block, a line whose first character is not whitespace
+// is prose: consecutive prose lines are one paragraph, joined on single spaces and wrapped to width. A line that
+// begins with whitespace is structure -- a policy ladder, a table, a list, an example -- and keeps its break and
+// its indent; only when it is itself too long does it wrap, as [wrapUsageLine] wraps a usage line. Authored
+// breaks in prose are therefore not load-bearing, which is the point: an author who wants a line kept indents it.
+//
+// Parameters:
+//   - `long`: the command's `Long`, as authored.
+//   - `width`: the column count to wrap to; zero or less leaves the text untouched.
+//
+// Returns:
+//   - `string`: the reflowed text, with every line right-trimmed.
+func wrapLong(long string, width int) string {
+
+	if width <= 0 {
+		return long
+	}
+
+	var lines []string
+	var paragraph []string
+	flush := func() {
+		if len(paragraph) > 0 {
+			lines = append(lines, wrapProse(strings.Join(paragraph, " "), width)...)
+			paragraph = nil
+		}
+	}
+
+	for _, line := range strings.Split(long, "\n") {
+		line = strings.TrimRight(line, " \t")
+		switch {
+		case line == "":
+			flush()
+			lines = append(lines, "")
+		case line[0] == ' ' || line[0] == '\t':
+			flush()
+			lines = append(lines, wrapUsageLine(line, width))
+		default:
+			paragraph = append(paragraph, line)
+		}
+	}
+	flush()
+
+	return strings.Join(lines, "\n")
+}
+
+// wrapProse word-wraps one paragraph to width, measuring in runes.
+//
+// Parameters:
+//   - `text`: the paragraph; runs of whitespace collapse to one space.
+//   - `width`: the column count to wrap to.
+//
+// Returns:
+//   - `[]string`: the paragraph's lines, none over width unless a single word is.
+func wrapProse(text string, width int) []string {
+
+	var lines []string
+	current := ""
+
+	for _, word := range strings.Fields(text) {
+		switch {
+		case current == "":
+			current = word
+		case len([]rune(current))+1+len([]rune(word)) > width:
+			lines = append(lines, current)
+			current = word
+		default:
+			current += " " + word
+		}
+	}
+	if current != "" {
+		lines = append(lines, current)
+	}
+
+	return lines
+}
+
 // endregion
@@ -852,6 +852,15 @@ does not.
 Help text is the specification a user reads. It states what the command does, what its flags mean, and what
 its output is — including, for a multi-artifact command, the names of the artifacts it writes.
 
+**Help wraps to the terminal, and an indent means "keep this line".** Flag usage reflows to the width the
+program reports — `COLUMNS`, else the terminal capped at 120, else 100 — with continuations hanging under the
+text they continue ([#755](https://github.com/NobleFactor/devlore-cli/issues/755)). A command's `Long` reflows
+under one convention ([#759](https://github.com/NobleFactor/devlore-cli/issues/759)): an unindented line is
+prose and joins its neighbors into a paragraph; an indented line is structure — a policy ladder, a table, a
+list, an example — and keeps its break and its indent, wrapping only if it is itself too long. Authored breaks
+in prose are not load-bearing; an author who wants a line kept indents it. Man pages and the generated
+reference read `Long` as authored.
+
 **`man` is the one route to man pages (ruled 2026-09-02).** The shared `man [command]` from [NewRootCmd]
 generates the pages and displays or installs them, the same on all four programs, and `self install` writes
 them under the prefix. `star docs man` duplicated that route and `star docs markdown` duplicated `make docs`;