feat(phase9-B): reinforce active memories from captured interactions

Phase 9 Commit B from the agreed plan. With Commit A capturing what
AtoCore fed to the LLM and what came back, this commit closes the
weakest part of the loop: when a memory is actually referenced in a
response, its confidence should drift up, and stale memories that
nobody ever mentions should stay where they are.

This is reinforcement only — nothing is promoted into trusted state
and no candidates are created. Extraction is Commit C.

Schema (additive migration):
- memories.last_referenced_at DATETIME      (null by default)
- memories.reference_count    INTEGER DEFAULT 0
- idx_memories_last_referenced on last_referenced_at
- memories.status now accepts the new "candidate" value so Commit C
  has the status slot to land on. Existing active/superseded/invalid
  rows are untouched.

New module: src/atocore/memory/reinforcement.py
- reinforce_from_interaction(interaction): scans the interaction's
  response + response_summary for echoes of active memories and
  bumps confidence / reference_count for each match
- matching is intentionally simple and explainable:
  * normalize both sides (lowercase, collapse whitespace)
  * require >= 12 chars of memory content to match
  * compare the leading 80-char window of each memory
- the candidate pool is project-scoped memories for the interaction's
  project + global identity + preference memories, deduplicated
- candidates and invalidated memories are NEVER reinforced; only
  active memories move

Memory service changes:
- MEMORY_STATUSES = ["candidate", "active", "superseded", "invalid"]
- create_memory(status="candidate"|"active"|...) with per-status
  duplicate scoping so a candidate and an active with identical text
  can legitimately coexist during review
- get_memories(status=...) explicit override of the legacy active_only
  flag; callers can now list the review queue cleanly
- update_memory accepts any valid status including "candidate"
- reinforce_memory(id, delta): low-level primitive that bumps
  confidence (capped at 1.0), increments reference_count, and sets
  last_referenced_at. Only active memories; returns (applied, old, new)
- promote_memory / reject_candidate_memory helpers prepping Commit C

Interactions service:
- record_interaction(reinforce=True) runs reinforce_from_interaction
  automatically when the interaction has response content. reinforcement
  errors are logged but never raised back to the caller so capture
  itself is never blocked by a flaky downstream.
- circular import between interactions service and memory.reinforcement
  avoided by lazy import inside the function

API:
- POST /interactions now accepts a reinforce bool field (default true)
- POST /interactions/{id}/reinforce runs reinforcement on an existing
  captured interaction — useful for backfilling or for retrying after
  a transient error in the automatic pass
- response lists which memory ids were reinforced with
  old / new confidence for audit

Tests (17 new, all green):
- reinforce_memory bumps, caps at 1.0, accumulates reference_count
- reinforce_memory rejects candidates and missing ids
- reinforce_memory rejects negative delta
- reinforce_from_interaction matches active memory
- reinforce_from_interaction ignores candidates and inactive
- reinforce_from_interaction requires minimum content length
- reinforce_from_interaction handles empty response cleanly
- reinforce_from_interaction normalizes casing and whitespace
- reinforce_from_interaction deduplicates across memory buckets
- record_interaction auto-reinforces by default
- record_interaction reinforce=False skips the pass
- record_interaction handles empty response
- POST /interactions/{id}/reinforce runs against stored interaction
- POST /interactions/{id}/reinforce returns 404 for missing id
- POST /interactions accepts reinforce=false

Full suite: 135 passing (was 118).

Trust model unchanged:
- reinforcement only moves confidence within the existing active set
- the candidate lifecycle is declared but only Commit C will actually
  create candidate memories
- trusted project state is never touched by reinforcement

Next: Commit C adds the rule-based extractor that produces candidate
memories from captured interactions plus the promote/reject review
queue endpoints.

src/atocore/api/routes.py

@@ -30,11 +30,15 @@ from atocore.interactions.service import (
     list_interactions,
     record_interaction,
 )
+from atocore.memory.reinforcement import reinforce_from_interaction
 from atocore.memory.service import (
+    MEMORY_STATUSES,
     MEMORY_TYPES,
     create_memory,
     get_memories,
     invalidate_memory,
+    promote_memory,
+    reject_candidate_memory,
     supersede_memory,
     update_memory,
 )
@@ -461,6 +465,7 @@ class InteractionRecordRequest(BaseModel):
     memories_used: list[str] = []
     chunks_used: list[str] = []
     context_pack: dict | None = None
+    reinforce: bool = True
 
 
 @router.post("/interactions")
@@ -468,9 +473,11 @@ def api_record_interaction(req: InteractionRecordRequest) -> dict:
     """Capture one interaction (prompt + response + what was used).
 
     This is the foundation of the AtoCore reflection loop. It records
-    what the system fed to an LLM and what came back, but does not
-    promote anything into trusted state. Phase 9 Commit B/C will layer
-    reinforcement and extraction on top of this audit trail.
+    what the system fed to an LLM and what came back. If ``reinforce``
+    is true (default) and there is response content, the Phase 9
+    Commit B reinforcement pass runs automatically, bumping the
+    confidence of any active memory echoed in the response. Nothing is
+    ever promoted into trusted state automatically.
     """
     try:
         interaction = record_interaction(
@@ -483,6 +490,7 @@ def api_record_interaction(req: InteractionRecordRequest) -> dict:
             memories_used=req.memories_used,
             chunks_used=req.chunks_used,
             context_pack=req.context_pack,
+            reinforce=req.reinforce,
         )
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
@@ -493,6 +501,33 @@ def api_record_interaction(req: InteractionRecordRequest) -> dict:
     }
 
 
+@router.post("/interactions/{interaction_id}/reinforce")
+def api_reinforce_interaction(interaction_id: str) -> dict:
+    """Run the reinforcement pass on an already-captured interaction.
+
+    Useful for backfilling reinforcement over historical interactions,
+    or for retrying after a transient failure in the automatic pass
+    that runs inside ``POST /interactions``.
+    """
+    interaction = get_interaction(interaction_id)
+    if interaction is None:
+        raise HTTPException(status_code=404, detail=f"Interaction not found: {interaction_id}")
+    results = reinforce_from_interaction(interaction)
+    return {
+        "interaction_id": interaction_id,
+        "reinforced_count": len(results),
+        "reinforced": [
+            {
+                "memory_id": r.memory_id,
+                "memory_type": r.memory_type,
+                "old_confidence": round(r.old_confidence, 4),
+                "new_confidence": round(r.new_confidence, 4),
+            }
+            for r in results
+        ],
+    }
+
+
 @router.get("/interactions")
 def api_list_interactions(
     project: str | None = None,