Render the history's nested code span, and say the plan-item entry holds over a restructure

docs/comprehension-history.md

@@ -1465,7 +1465,7 @@ Mid A, decided by:
 
 Inherited architect, decided by:
 
-- Locality, Self-sufficiency: `src/markdown/emit/inline-line.ts:71` `portableLineFallback`, together with `src/markdown/emit/inline-line.ts:115` `linePass` and `src/markdown/portable/inline-reduction.ts:168` `trimmedEdges`. The reducer now trims edges by the spanned grouping and judges fallbacks on the parted line, and the writer then prefers the spanned line, so three steps read two different lines. For `**Run `npm ci` first**` the parted line traces as misflanked and `strong` should drop, and only `adf-to-portable-markdown.test.ts:426` showed otherwise: it survives because `emitEmphasis` spells the kept edge space as `!adf:text`, in a portable verdict line whose directive the portable writer would never emit, and no comment states this.
+- Locality, Self-sufficiency: `src/markdown/emit/inline-line.ts:71` `portableLineFallback`, together with `src/markdown/emit/inline-line.ts:115` `linePass` and `src/markdown/portable/inline-reduction.ts:168` `trimmedEdges`. The reducer now trims edges by the spanned grouping and judges fallbacks on the parted line, and the writer then prefers the spanned line, so three steps read two different lines. For ``**Run `npm ci` first**`` the parted line traces as misflanked and `strong` should drop, and only `adf-to-portable-markdown.test.ts:426` showed otherwise: it survives because `emitEmphasis` spells the kept edge space as `!adf:text`, in a portable verdict line whose directive the portable writer would never emit, and no comment states this.
 - Locality: `src/markdown/emit/inline-line.ts:267` `nodesInRun`, with `src/markdown/emit/line-escaping.ts:22` `MarkRun`. In the base, a `RunNode`'s `outer` always equalled the walk's `depth`, and `depth` was always an index into a node's marks; now `MarkRun.depth` is a mark index only on a parted line. `withoutMarks` trusts that index, and it holds only because `linePass` and `portableLineFallback` both route fallbacks through the parted attempt, in another file. `tryLink`'s `nodes[0]?.outer ?? 0` is safe only if the first node is always a holder, which the reader has to derive.
 - Locality, Shape: `src/markdown/portable/inline-reduction.ts:218` `edgeDepth`, with `src/markdown/emit/inline-line.ts:282` `runsSharedWithNext`. The base's local `sharedRuns` is gone, a real gain because the grouping now lives in one place. The replacement is a second recursive walk in the emitter, `countSharedRuns`, which returns silently past `largestNesting` where `emitRun` refuses; its result is a count of runs, yet `edgeDepth` uses it as an index into the leaf's marks, and nothing says why the two agree on a spanned line.
 - Shape: `src/markdown/emit/inline-line.ts:40` `InlineContext`. `spans` and `spansLines` sit on adjacent lines and mean unrelated things: a run across nodes, and a hard break across lines. `spans` also means code spans at `emitMarkedRun` and at `inline-reduction.ts:248`, while `runSpans` and `codeSpans` read as siblings, and the new boolean is passed bare at its call sites.

docs/decisions.md

@@ -714,6 +714,7 @@ Locality worse, no plan item of its release reworked that code, and a restructur
 addressed most of its places. Serves code health. Valid while the comprehension check runs once per
 chunk.
 
+Where a plan item of the release already restores that code, the entry above holds instead, and the chunk restructures nothing.
 Each later ruling reads the restructured head against the first ruling's base, with the same seats,
 and every ruling stays in the history. Each restructure runs one rung higher; past the top rung,
 the maintainer decides. A ruling judges the code, never the behaviour: item 91's spanning stays, since the