Adopt house golangci-lint config; fix all approved-linter findings

.golangci.yml is the prompts-repo standard verbatim plus one approved
exception (paralleltest, sneak 2026-07-06). Roughly 1,500 findings
fixed:

- autofix sweep (wsl_v5/nlreturn/intrange/modernize formatting), with
  the misspell autofix REVERTED where it rewrote authentic C game text
  ("missle vanishes" stays, with nolint and a comment)
- error handling: errcheck sites get real handling — saveFile now
  closes explicitly and removes corrupt saves, scoreboard writes are
  documented best-effort, err113 sentinel errors (ErrSaveOutOfDate,
  ErrScreenTooSmall); panics allowed for unrecoverable states per
  MEMORY.md policy
- gosec: real fixes (ParseInt for SEED, 0600 scorefile) and justified
  per-line nolints for provably-bounded conversions (randomMonsterLetter
  helper collapses eight rnd(26)+'A' sites)
- API tidying from linters: pointer receivers on flag types
  (recvcheck), msg helpers renamed addmsgf/doaddf/Printwf/MvPrintwf
  (goprintffuncname), myExit()/findFloor(monst)/mkGameInput(t) drop
  always-constant params (unparam), gameEnd carries no status
- gocritic/staticcheck: if-else chains to switches, the pack.c
  inventory filter untangled into matchesFilter, main.go split so
  defers run before exit (exitAfterDefer, funlen)
- revive doc comments on all exported flag types/consts/methods

Remaining findings are confined to linters pending sneak's exception
decision (mnd, gochecknoglobals, cyclop, nestif, gocognit, exhaustive,
goconst, testpackage); TODO.md records the state. MEMORY.md added at
repo root as the project's agent working notes.

game/chase.go

@@ -11,21 +11,26 @@ func (g *RogueGame) runners(int) {
 	for _, tp := range list {
 		if !tp.On(Held) && tp.On(Awake) {
 			origPos := tp.Pos
+
 			wastarget := tp.On(Targeted)
 			if g.moveMonst(tp) == -1 {
 				continue
 			}
+
 			if tp.On(Flying) && distCp(g.Player.Pos, tp.Pos) >= 3 {
 				if g.moveMonst(tp) == -1 {
 					continue
 				}
 			}
+
 			if wastarget && origPos != tp.Pos {
 				tp.Flags.Clear(Targeted)
+
 				g.ToDeath = false
 			}
 		}
 	}
+
 	if g.HasHit {
 		g.endmsg()
 		g.HasHit = false
@@ -40,12 +45,15 @@ func (g *RogueGame) moveMonst(tp *Monster) int {
 			return -1
 		}
 	}
+
 	if tp.On(Hasted) {
 		if g.doChase(tp) == -1 {
 			return -1
 		}
 	}
+
 	tp.Turn = !tp.Turn
+
 	return 0
 }
 
@@ -62,10 +70,13 @@ func (g *RogueGame) relocate(th *Monster, newLoc Coord) {
 		if oroom != th.Room {
 			th.Dest = g.findDest(th)
 		}
+
 		th.Pos = newLoc
 		g.Level.SetMonsterAt(newLoc.Y, newLoc.X, th)
 	}
+
 	g.move(newLoc.Y, newLoc.X)
+
 	if g.seeMonst(th) {
 		g.addch(th.Disguise)
 	} else if g.Player.On(SenseMonsters) {
@@ -86,6 +97,7 @@ func (g *RogueGame) doChase(th *Monster) int {
 	if th.On(Greedy) && rer.GoldVal == 0 {
 		th.Dest = &p.Pos // if gold has been taken, run after hero
 	}
+
 	var ree *Room // find room of chasee
 	if th.Dest == &p.Pos {
 		ree = p.Room
@@ -94,6 +106,7 @@ func (g *RogueGame) doChase(th *Monster) int {
 	}
 	// We don't count doors as inside rooms for this routine
 	door := g.Level.Char(th.Pos.Y, th.Pos.X) == Door
+
 	var this Coord
 
 over:
@@ -107,9 +120,11 @@ over:
 				mindist = curdist
 			}
 		}
+
 		if door {
 			rer = &g.Level.Passages[*g.Level.FlagsAt(th.Pos.Y, th.Pos.X)&FPassNum]
 			door = false
+
 			goto over
 		}
 	} else {
@@ -122,18 +137,22 @@ over:
 			distCp(th.Pos, p.Pos) <= BoltLength*BoltLength &&
 			!th.On(Cancelled) && g.rnd(dragonShot) == 0 {
 			g.Delta.Y = sign(p.Pos.Y - th.Pos.Y)
+
 			g.Delta.X = sign(p.Pos.X - th.Pos.X)
 			if g.HasHit {
 				g.endmsg()
 			}
+
 			g.fireBolt(th.Pos, &g.Delta, "flame")
 			g.Running = false
 			g.Count = 0
+
 			g.Quiet = 0
 			if g.ToDeath && !th.On(Targeted) {
 				g.ToDeath = false
 				g.Kamikaze = false
 			}
+
 			return 0
 		}
 	}
@@ -147,15 +166,19 @@ over:
 				if th.Dest == &obj.Pos {
 					detachObj(&g.Level.Objects, obj)
 					attachObj(&th.Pack, obj)
+
 					if th.Room.Flags.Has(Gone) {
 						g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Passage)
 					} else {
 						g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Floor)
 					}
+
 					th.Dest = g.findDest(th)
+
 					break
 				}
 			}
+
 			if th.Type != 'F' {
 				stoprun = true
 			}
@@ -165,11 +188,13 @@ over:
 			return 0
 		}
 	}
+
 	g.relocate(th, g.chRet)
 	// And stop running if need be
 	if stoprun && th.Pos == *th.Dest {
 		th.Flags.Clear(Awake)
 	}
+
 	return 0
 }
 
@@ -180,6 +205,7 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 	p := &g.Player
 	er := tp.Pos
 	plcnt := 1
+
 	var curdist int
 
 	// If the thing is confused, let it move randomly. Invisible Stalkers
@@ -206,6 +232,7 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 		if ey >= NumLines-1 {
 			ey = NumLines - 2
 		}
+
 		ex := er.X + 1
 		if ex >= NumCols {
 			ex = NumCols - 1
@@ -215,11 +242,13 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 			if x < 0 {
 				continue
 			}
+
 			for y := er.Y - 1; y <= ey; y++ {
 				tryp := Coord{X: x, Y: y}
 				if !g.diagOk(er, tryp) {
 					continue
 				}
+
 				ch := g.Level.VisibleChar(y, x)
 				if stepOk(ch) {
 					// If it is a scroll, it might be a scare monster
@@ -227,12 +256,15 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 					// it is.
 					if ch == Scroll {
 						var found *Object
+
 						for _, obj := range g.Level.Objects {
 							if y == obj.Pos.Y && x == obj.Pos.X {
 								found = obj
+
 								break
 							}
 						}
+
 						if found != nil && found.ScrollKind() == ScrollScareMonster {
 							continue
 						}
@@ -258,6 +290,7 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 			}
 		}
 	}
+
 	return curdist != 0 && g.chRet != p.Pos
 }
 
@@ -266,7 +299,9 @@ func (g *RogueGame) setOldch(tp *Monster, cp Coord) {
 	if tp.Pos == cp {
 		return
 	}
+
 	sch := tp.OldCh
+
 	tp.OldCh = g.mvinch(cp.Y, cp.X)
 	if !g.Player.On(Blind) {
 		if (sch == Floor || tp.OldCh == Floor) && tp.Room.Flags.Has(Dark) {
@@ -284,20 +319,25 @@ func (g *RogueGame) seeMonst(mp *Monster) bool {
 	if p.On(Blind) {
 		return false
 	}
+
 	if mp.On(Invisible) && !p.On(CanSeeInvisible) {
 		return false
 	}
+
 	y, x := mp.Pos.Y, mp.Pos.X
 	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
 		if y != p.Pos.Y && x != p.Pos.X &&
 			!stepOk(g.Level.Char(y, p.Pos.X)) && !stepOk(g.Level.Char(p.Pos.Y, x)) {
 			return false
 		}
+
 		return true
 	}
+
 	if mp.Room != p.Room {
 		return false
 	}
+
 	return !mp.Room.Flags.Has(Dark)
 }
 
@@ -330,6 +370,7 @@ func (g *RogueGame) roomin(cp Coord) *Room {
 	}
 
 	g.msg("in some bizarre place (%d, %d)", cp.Y, cp.X)
+
 	return nil
 }
 
@@ -338,9 +379,11 @@ func (g *RogueGame) diagOk(sp, ep Coord) bool {
 	if ep.X < 0 || ep.X >= NumCols || ep.Y <= 0 || ep.Y >= NumLines-1 {
 		return false
 	}
+
 	if ep.X == sp.X || ep.Y == sp.Y {
 		return true
 	}
+
 	return stepOk(g.Level.Char(ep.Y, sp.X)) && stepOk(g.Level.Char(sp.Y, ep.X))
 }
 
@@ -351,6 +394,7 @@ func (g *RogueGame) cansee(y, x int) bool {
 	if p.On(Blind) {
 		return false
 	}
+
 	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
 		if g.Level.FlagsAt(y, x).Has(FPassage) {
 			if y != p.Pos.Y && x != p.Pos.X &&
@@ -359,11 +403,13 @@ func (g *RogueGame) cansee(y, x int) bool {
 				return false
 			}
 		}
+
 		return true
 	}
 	// We can only see if the hero is in the same room as the coordinate
 	// and the room is lit, or if it is close.
 	rer := g.roomin(Coord{X: x, Y: y})
+
 	return rer == p.Room && !rer.Flags.Has(Dark)
 }
 
@@ -374,22 +420,28 @@ func (g *RogueGame) findDest(tp *Monster) *Coord {
 	if prob <= 0 || tp.Room == g.Player.Room || g.seeMonst(tp) {
 		return &g.Player.Pos
 	}
+
 	for _, obj := range g.Level.Objects {
 		if obj.Kind == KindScroll && obj.ScrollKind() == ScrollScareMonster {
 			continue
 		}
+
 		if g.roomin(obj.Pos) == tp.Room && g.rnd(100) < prob {
 			claimed := false
+
 			for _, other := range g.Level.Monsters {
 				if other.Dest == &obj.Pos {
 					claimed = true
+
 					break
 				}
 			}
+
 			if !claimed {
 				return &obj.Pos
 			}
 		}
 	}
+
 	return &g.Player.Pos
 }