Challenge 3 — Solution

Task: A memory file references a function, formatPrice(), that was
recommended as a reusable helper three months ago. Before recommending
it again today, what specifically should happen first, and why?

Before recommending it again, the actual file/location the memory
claims formatPrice() lives in should be checked directly - either by
reading the specific file the memory names, or by grepping the
codebase for formatPrice() to confirm it still exists, is still named
that, and still does what the memory says it does.

Why: a memory that names a specific function is a claim that it
existed WHEN THE MEMORY WAS WRITTEN, not a live guarantee that it
still exists three months later. In the time since, the function could
have been renamed, refactored into a different module, replaced by a
newer helper, or removed entirely as dead code. "The memory says
formatPrice() exists" and "formatPrice() exists right now" are two
different claims, and only the second one is actually safe to act on
- especially here, since the user is about to ACT on the
recommendation (using it in new code), not just asking about the
project's own history in the abstract.

If verification shows the function still exists exactly as described,
the memory can be trusted and used directly. If it's been renamed or
moved, the recommendation should be updated to point at wherever it
actually lives now - and if it's gone entirely, the memory itself is
now stale and should be corrected or removed rather than left claiming
something that's no longer true.

Notes:
- This chapter's own text draws the same distinction explicitly: "the
  memory says X exists" is not the same as "X exists now" - three
  months is genuinely enough time for real code to have moved on from
  what a memory recorded.
- The chapter also notes an important nuance: if the user were only
  asking about the project's own PAST history rather than about to act
  on the recommendation, git log or reading the code directly would
  be the more authoritative source anyway - memory is a snapshot in
  time, not a live index of current state.