You are reading one slice of a finished coding session in a software repository and proposing
durable lessons to persist into a knowledge graph. The slice contains:
- the conversation turns the candidates below were learned in, written as "User: ..." /
  "Assistant: ...", in chronological order: each one a user request and the agent's final
  answer to it,
- candidate memories, written as "Candidate <id> (<section>): ...", harvested from the tool
  traces of those turns, in the order of the turns.
  A candidate that begins with "[state-key: <key>]" is a current state (see STATE LESSONS).

Propose what a developer starting a different task in this repository should know. For each lesson
return:
- working_statement: one standalone sentence of at most about 40 words, understandable with no
  session context, that states one fact and names the files, symbols, commands or tests it is
  about, with file paths relative to the repository root.
- member_entry_ids: the ids of the candidate memories the lesson draws from (may be empty if it comes
  only from the conversation).
- state_key: only for a state lesson (see STATE LESSONS); otherwise empty.

Propose at most 5 lessons for this slice, chosen in this order of priority:
1. answers to searches that cost the session effort: where a kind of code lives, how parts connect;
2. pitfalls that caused an error or a failed test, including tool or platform behaviour of this
   environment, with the cause and what worked instead; a pitfall that caused repeated failures is
   stated once, as the problem followed by "→" and the form that worked;
3. conventions of the project (how errors are reported, how tests are written, what must stay
   true), each as the rule plus one file or class that follows it.
In addition to these 5, STATE LESSONS (a current state that a later lesson with the same key
replaces; at most one per key):
- FOOTPRINT, state_key "footprint:<feature>" (<feature>: a short lower-case hyphenated name of
  the feature): if the slice changed code, what the feature consists of after the change: the goal
  in the user's words, and every kind of place it touches (code, tests, packaging, documentation,
  task lists), so that a later task can extend or remove it.
- TEST STATE, state_key "test-baseline": if the slice ran the test suite, the command, the passed
  and failed counts, and which tests fail at the end of the slice and why, or that the suite passes.
  It records only the test command, the counts and the failing tests with their reasons; it never
  describes git or working-tree state (committed or uncommitted changes).
Keep a state key given by a candidate unless the slice shows a different feature.

Rules:
- FINAL STATE ONLY: judge every candidate against what happened after it. Drop a candidate that a
  later step fixed, reverted or contradicted. Drop failures and pending work unless the end of the
  slice shows they still hold, or they are pitfalls with cause and fix.
- ONE LESSON PER SUBJECT: merge candidates about the same file or symbol and the same aspect. Merge
  candidates that describe the change into the footprint, and do not restate it elsewhere.
- REUSABLE: keep what helps a different task; drop what only explains the task just finished, the
  internals of code the session only read, and what the named file shows directly.
- FACTS, NOT STEPS: state how things are and why; never an instruction to perform.
- REASONS: state the reason when the slice shows it; never invent one.
- NO LOCAL DETAILS: never include absolute paths, home directories, user names, commit hashes or
  line numbers.
- GROUNDED: every lesson must be supported by the slice. Do not invent specifics, do not write what
  something "seems" or "probably" does, and do not promote a claim that exists only in an assistant
  answer unless a candidate or the user backs it.
- Judge by content, not by the candidate's section label.

Return zero or more proposed lessons. It is fine to return none.
