[OmarAlJarrah]

Summary

This gives a design something that can disagree with it, fixes what reviews of past PRs found wrong
or missing in the skills, and brings the tree to the styleguide rules it broke.

Read it by commit. 315b0fa4 adds the license header to every Go file outside testdata, with the lint
that holds it, and the sweeps before it are each one mechanism.

A design's premise

A design change has no output to compare, so the checks that catch a defect in code can pass while
the design's premise is wrong. #1167 showed it. morphic-changing-the-ir fired and its step said
"weigh two designs", which was followed: the issue's option was weighed against one alternative, and
a program ran the proposed rules over the golden spec and the corpus. Every failure was placed, and
the design was still built on a fact nobody had counted. It kept one error type per body, but most
operations with several error bodies use one type for all of them, so the status is what tells
failures apart. A reviewer's question led to that count, not a check.

That program could not have disagreed: it assumed the premise it was run to support. So this adds
what can:

• measure-the-premise (morphic-changing-the-ir): write the job a consumer does and the fact
  about real input the shape rests on, and count that fact before choosing. Running the rules shows
  only that they are total.
• weigh-the-framing (morphic-changing-the-ir): weigh a design outside the issue's framing, and
  call a choice forced only after naming what the comparison held fixed and changing it.
• review-design-rules (morphic-reviewing-prs): a normative document has no output for the
  behaviour pass, so read its rules against each other and against another protocol, run them with
  a planted defect, check each premise, and run its samples as printed.
• tracker-on-what-a-rule-settles (morphic-reviewing-prs, in the claims pass): search the
  tracker for each construct a rule decides, and require every open issue on it to be closed by the
  change, cited as left open, or answered.

The failed step is sharpened rather than given a copy: "weigh two designs" becomes two steps pointing
at the new rules, and morphic-designing-code gains a row, so a shape outside the IR reaches them
too.

It also states that correctness comes first, in a new CLAUDE.md section. The priority order was in
the Go style section alone, so a design or a document was outside it, and morphic-designing-code
opened on scale and simplicity without naming correctness. CLAUDE.md is the home rather than a new
skill because a skill loads on a trigger and this has to hold always.

No test or lint can tell whether a premise was examined, or an option shown correct, so these are
rules and not checks. They raise the odds; they do not guarantee.

What reviews of past PRs found

Each item of #1162 went where morphic-curating-skills sends it, a check before a rule and a sharper
rule before a copy, which the issue's "each with a Rule, Why and Probe" skipped.

Item	Where it went
1	skills_lint.py exits 2 on a tree with no skill, rather than printing clean (0 skills)
2	the push checklist's diff grep leaves go.sum out
3	sweep.py reads a version key anywhere in a YAML file
4, 18	ignore rules split out of diff-contains-only-in-scope-files into ignore-rule-both-ways, which cites #324 for the restored entry and probes an added pattern too
5	cpu-time-without-a-counter: CPU time of alternated runs, not the benchmarks the issue proposed, which report wall clock and read their own fixtures
6	toolchain-the-tree-names
7	argv-differential
8	catch-reaches-one-goroutine, citing barrier/doc.go and goroutine-per-node rather than restating them
9	check-stays-silent-on-valid-input sharpened: a shortcut reader that cannot decide falls back to the full read
10	a docs/parser-library.md entry, scalar-resolution, with a canary, since it is a library behaviour and not a skill's to state
11	null-decodes-to-zero
12	heuristic-default-on-golden
13	character-predicate-witness-per-class sharpened: a redefined predicate is rechecked at each call site, since #189 shows no upper and lower pair
14	resolve-to-true-target restored from the catalog the skills were built from, with its probe extended to annotations
15	every-return-path-delivers-diagnostics sharpened, as it already owned the class; split-guard-per-site points at it
16	no-maintained-counts-or-state-in-prose's Probe also reads commit bodies, as the default squash pastes them; a false count in a pushed body is fixed in the squash body at merge, since a pushed branch is never rewritten

Item 3 is wider than the issue asked. YAML can also write a version key after an anchor, a tag or a
? , so the reader takes one anywhere rather than special-casing {. A file naming one in a comment
is compiled too and fails alike on both builds, which costs less than a spec left out. A key spelled
through an escape or a folded line is still missed, though the compiler reads it; only a YAML reader
would see it, the standard library has none, and the pattern's comment says so.

The other issues

• skills: the lint reports a quoted path in a one-word span as missing #1161: a one-word span and a command's words read through one function, so a quoted path that exists
  is no longer reported missing.
• skills: a cost measured over a whole compile cannot see a later stage #1165: cost-of-a-later-stage, for a stage a compile's own spread would hide.
• skills: the reviewing skill never reads an edited rule against its neighbours #1160: edited-rule-against-its-neighbours, a class of claim for a change to the skills or
  CLAUDE.md: name the acts each edited rule governs, find the other rules governing them, and read
  each pair. A script can find the pair but not tell a conflict from a restatement.
• skills: say what the order oracle compares, since a fact on an operation passes it unread #1166: order-oracle-reads-what-it-compares, and a sentence in CLAUDE.md. Both point at
  diffOrderInvariants rather than list what it compares, which has already moved since the issue
  was written, when servers joined.

The styleguide's way of thinking

The skills mostly record what went wrong. The org's styleguide also says how to think before anything
does, and most of that reached the skills only as failures to avoid. This puts four habits where a
decision is made, rather than copying its rules, which CLAUDE.md already carries:

• The order style concerns resolve in. CLAUDE.md now says clarity, simplicity, concision,
  maintainability, consistency, which was written nowhere here, and that consistency never overrides
  the others, since matching the surrounding code is the easiest defence of a bad pattern.
  morphic-designing-code opens on the stance beside it: data and functions, immutable, explicit,
  errors handled.
• Two questions at design time. Its table gains what would make a function wrong and what a path
  every input takes costs, as morphic-measuring-performance fires only once a change is tuned or a
  cost claimed.
• What good looks like. Each row of that table names code to copy, since nearly every rule is
  drawn from a failure. skills_lint.py now holds a Go name placed in a file to what the file
  declares, so an example cannot go stale unseen.
• A review question. Pass 3 questions any added line nobody can explain.

These are lenses and not rules: they have no Probe, and no check can tell whether one was applied.

Checking a change against the styleguide

CLAUDE.md makes the guide binding, and the review's written-rules pass read only the excerpt
CLAUDE.md carries. Each of the guide's 215 rules ends in an Enforcement line: 187 name review
and 104 name nothing else, so no tool holds about half of it (styleguide @591e5243,
grep -h '^\*\*Enforcement:\*\*' go/[0-9]*.md | grep -ci review). #1172 asked how to check a change
against it:

Option	Why not
Install the org's plugin	.gitignore keeps everything under .claude but the skills out, so a clone cannot declare it. Installed, its rule 9 forbids the recursion TestLoweringRecursion_IsOnlyTheKnownCycles pins, and its last step passes a tree below the coverage gate.
Widen the review pass alone	Nobody writing Go runs that pass, and the departures would still need a home.
A morphic skill reading the chapters	Chosen.

morphic-checking-style lists the rule headings of the chapters a change calls for, and reads a
rule's body only where a line looks like a breach: the chapters run to about 32,000 words, and an
exception sits in a rule's body, never its heading. The review's pass takes it, and CLAUDE.md names
it.

references/departures.md holds each departure with what holds it. The issue named four, and reading
the chapters against the tree added five: chapter 01's linter set, a source's dates kept as text, a
stage that neither logs nor returns a spec problem as an error, the IR's embedded shapes, and
make gate as the finish.

Counting the tree also found rules it breaks with nothing recorded either way, and #1173 put each to
a ruling. Assertion helpers (6.4), type aliases at a boundary (5.9) and Example functions before a
stable API (11.5) are departures, and departures.md gives each reason. gosec stays off: it gave 174
findings, 16 in production and none of those a defect. The rest were breaches, and this brings the tree
to each, one commit an issue:

• Import aliases, lint: every import of oas3 aliases it to its own name, and nothing refuses a redundant alias #1175. The 67 imports aliasing oas3 to its own name lose the alias, and revive's
  redundant-import-alias refuses the shape.
• doc.go, test(archtest): nothing holds a package comment to doc.go, and 15 packages keep theirs elsewhere #1174. Fifteen packages move their comment unchanged, openapitest's TB leaves its
  doc.go, and TestPackages_KeepTheirCommentInDocGo holds every package to the rule.
• Compile-time assertions, pass+ir+engine: assert at compile time that exported types implement exported interfaces #1176. An exported type implementing an interface this module exports
  carries one beside its imports. An unexported one stays out, as the call passing it fails the build, and
  interface-assertions-stay-narrow says so.
• License headers, build: source files carry no license header, and CI checks none #1177. Every Go file outside testdata opens with one, as do the plants bar the
  one that shows the rule reaches, and goheader holds it. Five of six sibling repositories sampled carry a header. The wording is
  go-sdk's, and the holder is the one LICENSE and the README name, dexpace, where that header adds
  a person.
• t.Helper(), test: nothing holds an asserting test helper to t.Helper, and thelper cannot #1178, was no breach. CONTRIBUTING.md already exempts a function a table runs as a
  case's body, and thelper, which reads a signature, cannot see that: of the 298 functions it reports,
  294 are such cases, 2 are callbacks and 2 assert nothing. So thelper stays off, and
  TestTestHelpers_StartWithHelper checks the rule by use, which CONTRIBUTING.md said nothing did. A
  pushed commit body here, 1773af4a, calls these a breach and is wrong; it should not reach main.

Only http.DefaultClient remains in rules-the-tree-still-breaks, as its fix is #1036's time bound on a
network read. Rule 5.28, starting enums at one, is none of these: it excuses a zero that is the desired
default, and telling the tree's 22 apart means reading each.

The org skill's recursion line disagrees with the guide's own deviations table. That fix belongs in
the styleguide repository and is not made here.

What a published review procedure added

A published code-review plugin was read against morphic-reviewing-prs, principle by principle. What
the skills already held stays as it was, and no text is copied. Three things are new:

• disprove-each-finding. A finding is attacked before it is reported: its rule read for scope and
  exceptions, a decision looked for on the line, a tool's hits sorted. That would have stopped this
  branch filing 298 functions as a breach that none of them was.
• read-standing-reviews. A review reads what already stands on a PR, after the passes, as a list
  read first sets the agenda just as a PR body does.
• posted-findings. When asked to post: one comment a defect, code linked by full SHA, and a
  committable suggestion only where applying it alone is safe.

Where a principle opposed a rule here, each side had a point, so the rules keep the better part of both
rather than pick a winner:

The procedure	Here	Now
Give reviewers the PR's description	Read the diff without it (code-before-claims)	A blind first pass, then the stated intent tests each finding
Flag only the certain, nothing that depends on input	Nothing left to find, and hostile input is normal	rank-by-what-was-shown: the bar stays, a defect shows on its input, and what is only likely is a question:
Skip pre-existing issues	A defect the change exposes is in scope	One it exposes stays in scope, and one outside its mechanism is filed, not ranked
A confidence score	A finding needs its command	question: is the home of low confidence, with no score to argue over
Parallel independent reviewers	Passes run in one reader	fan-out-a-pass-to-a-reader: only when asked, one pass a reader, the code and no conclusion
Assume tools work	Validate the instrument	Already both: validate each once, against a known positive, then use it

edited-rule-against-its-neighbours now says the same of any pair of rules that conflict.

Found on the way

• A deep JSON file ended the whole sweep with RecursionError. It is now read as text.
• The curating skill said each push chains on the lint, while the shipping skill runs the lint in a
  checklist and pushes separately.
• diff-contains-only-in-scope-files said design-only PRs carried go.mod changes, which neither PR
  it cited shows, and a search of every PR numbered up to 340 found none that does. The clause goes.
• A merge can leave a sentence true of the PR it cites only as that PR once stood, and
  tracker-on-what-a-rule-settles went stale that way when docs(emitter-design): settle how an SDK reads a response #1167 landed naming the two issues it said
  docs(emitter-design): settle how an SDK reads a response #1167 left out. The Why is corrected, and reread-what-cites-a-merged-pr asks for the reread.
• A note in annotation.go said a site's referent is one hop, where both callers pass the chain's
  end, and docs/micro-compiler-design.md said the same in the present tense, true until feat(compilers/openapi)!: resolve schema $refs in the compiler #1016. The
  note now says what holds, and the design record moves to the past tense.

Left out

• skills: fix the flaws reviews of past PRs found in the skills #1162's item 10 records the parser's reading and changes no output: 0644 stays 420, as openapi: leading-zero YAML integers are stored with the wrong value, silently #104
  asked, where OpenAPI's recommended YAML 1.2 reads 644. The entry says so.
• skills: fix the flaws reviews of past PRs found in the skills #1162's item 17: TestGitAttributes_PinsLineEndings, TestGitAttributes_ResolveToLF and
  TestTrackedFiles_HoldNoCarriageReturn already hold the one instance there is, so it takes a check
  and not a rule.
• openapi: a use site takes its $ref chain's last annotations, skipping an alias's own #1029 stays open: a use site takes the annotations of a $ref chain's end, skipping an alias's own.
  resolve-to-true-target says so, and its probe gives each hop a distinct value.
• harness: the order-invariance oracle silently declines on any document using YAML anchors #403 stays open: a spec using YAML anchors is not permuted. order-oracle-reads-what-it-compares
  says so. Whether the oracle should compare operations is skills: say what the order oracle compares, since a fact on an operation passes it unread #1166's own out-of-scope question.

Closes #1160
Closes #1161
Closes #1162
Closes #1165
Closes #1166
Closes #1168
Closes #1170
Closes #1171
Closes #1172
Closes #1173
Closes #1174
Closes #1175
Closes #1176
Closes #1177
Closes #1178

Test plan

make gate passed on 6f59ffde, which holds main through #1167: fmt, vet, the vet rules, lint, planted
lint, build, 100% coverage under the race detector, fuzz and bench-smoke. The two commits since touch
.claude, CLAUDE.md, CONTRIBUTING.md and two comments in one test, and the lint, both scripts' tests,
internal/archtest and lint over that test pass on the head.

• skills_lint.py: clean, each rule within 150 words and each SKILL.md within its cap. The lint's
  and sweep's own tests pass, and each new test failed on the old code first.
• Forty-three defects planted in copies of the two scripts each reddened a test: the empty-tree guard
  off, narrowed or returning another code, each character path_word drops, each site not calling
  it, each part of the new SPEC, RecursionError uncaught among them, and each part of declares as
  first written.
• Nineteen more, planted in the rewritten declares and in the path a span reports, each redden a
  test, among them a struct header that misses a generic such as type G[K ~[]byte] struct.
• Each good example was read against its rule, and two first picks were dropped: scan.MaxNesting
  says it bounds a shape and not the spent quantity, and navigation mirrors the library where the
  rule says to call it. Renaming each named example makes the lint report it.
• TestLibraryBehaviour/scalar-resolution reddens when any of its eight rows is changed to another
  reading. morphic compile on the entry's sample gives the values it states.
• The sweep over testdata, base origin/main: 213 specs, 165 exiting 0 and 48 exiting 1 on both
  sides, none differing. Its reader over testdata keeps the same 213 specs, and over a local corpus
  of 1,952 it loses none and gains two files that only name a key. It now finds a 70 KB one-line
  flow spec, the shape that exits 2 at 40f12412 and 0 at its parent.
• The checklist's diff grep on refactor(cmd/morphic)!: run the CLI on cobra #815's first commit, 15c2ca10: 55 hits before, 0 with go.sum left
  out.
• At fix: settle what a case boundary is, and how a branch is named #189's first commit, 325d69c8, the four tests fail under bare go test and pass under the
  command toolchain-the-tree-names quotes.
• Each #N a new or changed Why cites was checked clause by clause against that PR's branch, not its
  squash, and git grep found no remaining mention of what the changed rules replaced.
• Every command a new rule quotes was run from the root, and the tracker searched for each construct
  these rules settle, which is where openapi: a use site takes its $ref chain's last annotations, skipping an alias's own #1029, harness: the order-invariance oracle silently declines on any document using YAML anchors #403 and openapi: leading-zero YAML integers are stored with the wrong value, silently #104 came from; openapi: leading-zero YAML integers are stored with the wrong value, silently #104 agrees with the new entry.
• morphic compile on a chain whose nearer hop writes a description gives the property the
  description at the chain's end, as the rewritten note says.
• edited-rule-against-its-neighbours run over each rule this branch adds or edits, by the act each
  governs. What it found is fixed: the maintained-count Probe set a commit body aside beside a rule
  asking that it could stand on main; the new skill softened rule 7.9 to a question where CLAUDE.md
  states it outright; its first pass dropped CLAUDE.md's own Go rules; standing reviews were read
  first, where they would set the agenda; and a finding could give a command or a rule, where the
  skill's Findings section asks for both.
• Every Probe and command morphic-checking-style quotes was run, and each guide rule number
  departures.md cites was matched to its heading.
• gosec at the pinned golangci-lint: each of the 16 production findings was read. The other 158,
  all in tests, were read by category alone.
• This branch's commit bodies, by the new Probe: with issue numbers and hashes set aside, each line
  holding a count was read and is true on the head.
• That skill was walked over fix(cmd/morphic)!: report a stop only for a run it stopped #1136. Its production lines gave no finding; its assertKept test
  helper reached rule 6.4 and, through the lookup, assertion-helpers-stand, which it meets by
  calling t.Helper(). As a second control, MarshalJSONTo in ir/json.go, a breach of rule 9.3 by
  its heading, is resolved by json-through-v2.
• Twenty-seven defects planted in the two new internal/archtest tests each redden one. On the real
  tree, deleting ir/irtest/doc.go, declaring a variable in pass/doc.go and taking t.Helper() out
  of assertKept each fail their test, and *ir.Any losing its marker fails the build at its
  assertion.
• goheader over the module and the plants draws the one planted finding. A header naming another
  holder is refused as well, checked by hand, as its two-line message cannot be a // want marker.
• The commits for lint: every import of oas3 aliases it to its own name, and nothing refuses a redundant alias #1175, test(archtest): nothing holds a package comment to doc.go, and 15 packages keep theirs elsewhere #1174, pass+ir+engine: assert at compile time that exported types implement exported interfaces #1176 and test: nothing holds an asserting test helper to t.Helper, and thelper cannot #1178 were rebuilt one at a time from a clean tree, and the
  result compared byte for byte with the tree tested.
• The sweeps hold by script, not by reading: each of the 1,045 files 315b0fa4 changes gains exactly the
  header's three lines, 8107d5da changes the 67 alias lines alone, 5a420c96 moves its 15 comments
  byte for byte, and b28cf2b6 adds assertions alone. The 42 Go files under other testdata stay as
  they were.
• The planted defects behind item 17's decision: dropping the eol=lf rule reddens both
  TestGitAttributes tests, and a CRLF in a tracked golden reddens
  TestTrackedFiles_HoldNoCarriageReturn.

[fuad-daoud]

Thanks, Omar. This closes most of #1162 well, and putting a check before a rule where one fits (items 1–3, 10) is better than what the issue proposed. Two issues and three nits below; the issues block Closes #1162 and the lint check's purpose respectively.

Scope. I reviewed through 69f37dbb and re-checked every finding below on 64b18771, where each still applies. ddf7cc23 and 64b18771 themselves (the edited-rule rule and morphic-checking-style) are not reviewed yet; I'll follow up on them. No gate rerun: the head contains main and CI passed on it.

#1162, item by item. Where the issue gave a probe, I reran it on the head.

#	Verdict	What showed it
1	Fixed	fresh git init: base clean (0 skills) exit 0, head exit 2
2	Fixed	15c2ca10^..15c2ca10: 55 hits, 0 with ':!go.sum'
3	Fixed	issue's probe [False, True] → [True, True]; sweep.py -b af1aae93: 213 specs, none differ
4, 18	Fixed	#324's branch: a89252c4 removes .claude/, 16bcd3e2 restores it
5	Different, reason holds	go test -bench reports wall time over its own fixtures
6	Fixed	at 325d69c8, 4 tests fail under go1.27.3 and pass under the rule's command
7	Fixed	morphic -- compile at 15c2ca10 prints help and exits 0, where its parent compiles
8, 13, 14, 15	Fixed	read against the cited PRs; 15 by reading #212's code only
9	Fixed	70 KB one-line flow spec: exit 2 at 40f12412, 0 at its parent
10	Different, reason holds	compiled values match the entry; each of the 8 rows, changed, reddens the canary
11	Fixed	json/v2 decodes null into a string as "" with no error
12	Fixed	the rule's jq on the golden spec: all 5 x-sunset values are dates
16	Not fixed	see the comment on derive-never-maintain.md
17	Declined, reason holds	the three tests exist; dropping eol=lf reddens both TestGitAttributes tests

The other closing keywords hold: #1161's own probe no longer reports the quoted paths, a three-hop chain compiles as #1171's new comment says, and #1165, #1166, #1168 and #1170 get what they ask for.

[fuad-daoud]

issue: item 16 is declined because a stale count in a commit body "cannot land", but it can: gh api repos/dexpace/morphic --jq .squash_merge_commit_message → COMMIT_MESSAGES, so a default squash pastes every branch commit's body. The recent merges' one-line PR: <url> bodies come from the merger's habit, not a setting. commit-and-pr-message-form says the same ("Every commit body could stand on main, since the default squash pastes them all"), as does CLAUDE.md, so this sentence now tells a reviewer to skip what those rules require to be right, and commit-and-pr-message-form's own Probe checks subjects, length and artifacts, not counts.

On this branch's own bodies, git log --format=%B af1aae93..HEAD | grep -cE '<this Probe's pattern>' gives 34 hits, so the probe has work here too. The fix is the issue's direction, and it lints clean:

Suggested change

	over comments and docs; derive or delete each hit. A commit body is left to
	`.claude/skills/morphic-shipping-prs/references/commits-and-prs.md#commit-and-pr-message-form`, as
	a merge sets its own (#1162).
	over comments and docs, and the same grep over `git log --format=%B origin/main..HEAD`, since
	the default squash pastes every branch commit's body; derive or delete each hit (#1162).

Closes #1162 is right once this lands.

[fuad-daoud]

issue: the \t alternative accepts any statement in a function body, not just a member of a group or struct, so a name that a file only calls passes as declared there. That is the staleness this check exists for: a function moved to a sibling file with a call left behind.

$ python3.14 -I -c 'import sys; sys.path.insert(0, ".claude/skills/morphic-curating-skills/scripts"); import skills_lint as s
src = "package ir\n\nfunc f() {\n\tGone()\n\tLocal := 1\n}\n"
print([s.declares(src, n) for n in ("Gone", "Local")])'
[True, True]

The test has a row for a comment mention but none for a statement; a row with func f() {\n\tCalled()\n} and `Called` in `ir/b.go` fails on this code. Holding the tab alternative to the inside of a block fixes the class:

# A const, var or type group, or a struct or interface type, to the parenthesis or brace closing it.
GO_BLOCK = re.compile(r"^(?:(?:const|var|type) \(|type \w+(?:\[[^\]\n]*\])? (?:struct|interface) \{)\n"
                      r"(.*?)^[)}]$", re.M | re.S)


def declares(source: str, name: str) -> bool:
    """Report whether Go source declares name: a function or method, a type, a constant or a
    variable, or a member of a group, struct or interface."""
    n = re.escape(name)
    if re.search(rf"^(?:func (?:\([^)]*\) )?|type |const |var ){n}\b", source, re.M):
        return True
    return any(re.search(rf"^\t{n}\b", body, re.M) for body in GO_BLOCK.findall(source))

On 64b18771 with this applied: a call and a := are refused; fields, const-group members, interface methods and a generic struct's fields are still accepted; test_skills_lint passes and the lint stays clean (9 skills).

[fuad-daoud]

nit: "not permuted at all" holds only where reversing would lift an alias above its anchor. reverseMappings declines only when the reversed tree no longer parses, so an anchor and alias that share a sequence are permuted: tags: [&t {name: a}, *t] and allOf: [&x {...}, *x] both come back permuted, while schemas: {A: &a {...}, B: *a} does not.

Suggested change

	response, needs its own two-order diff, however many specs reach the sweep, and a spec using YAML
	anchors is not permuted at all (#403).
	response, needs its own two-order diff, however many specs reach the sweep, and a spec is not
	permuted at all where reversing its mappings would lift an alias above its anchor (#403).

[fuad-daoud]

nit: "#1029 is open" is an issue's state in prose; it goes stale the day #1029 closes and nothing reads it. This is the only such statement the diff adds (is open|stays open|still open|until #).

Suggested change

	document, and takes a key and its value from one target. #1029 is open on what each hop lends a
	use site.
	document, and takes a key and its value from one target. What each hop lends a use site is
	#1029.

[fuad-daoud]

nit: rebinding tok here makes the "does not exist" message name the normalized path rather than what the author wrote: `$GOROOT/src/nope/x.go` is reported as GOROOT/src/nope/x.go does not exist, and `$WT/ir/walk.go` as WT/ir/walk.go. Both are paths nobody wrote; the test's expectations at lines 189, 197 and 200 were edited to drop the $ to match. absent's docstring already says it names the path "as shown".

Fix: keep the written form beside the normalized one, e.g. shown, tok = tok, path_word(tok) here and shown, word = word, path_word(word) in the command loop, give missing a shown: str = "" parameter, and call self.absent(shown or p, rel). Then only those two expectations change back.

[OmarAlJarrah]

Thanks. Took all five; here is what differs from your suggestions.

• Item 16. You were right that a commit body can land, and "cannot land" was wrong. The Probe reads commit bodies now, but a false count in one is fixed in the squash body at merge rather than deleted, since a pushed branch is never rewritten. The hits were mostly issue numbers, and each real count is true.
• declares. Fixed, with a wider header than your regex, which missed a generic such as type G[K ~[]byte] struct. There is a test row for it.
• The written path. Kept for one-word spans only. main already normalizes a command's word, and keeping that as written would print "$GOROOT"/src/..., which nobody wrote either.

The other two went in as you suggested.

Since you read it, the branch has grown, so please read it by commit. departures.md now records the rulings from #1173, and the tree is brought to them one issue a commit: #1175, #1174, #1176, #1178 and #1177. The header commit adds the header to every Go file outside testdata, with its lint and nothing else. morphic-checking-style, the edited-rule rule and the review rules in the last commit are still yours to review.