Give unit-test fixing access to memory, kept separate by test surface

The unit-test fix loop runs up to 20 attempts and produced no memory and
consumed none, even though it is doing the same thing the conformance loop
does: applying a change and observing what a test run says about it.

Both loops now write and read memory, and the two are kept distinct by the
`suite` field the record schema already carried.

Writing:
- run_unit_tests records the observation after each run, pairing the fix
  applied before it with the outcome, exactly as the conformance path does
- UnitTestsRunningContext carries the pending intervention across the run
- records are written with suite=unittest, so the surface is visible both in
  the record and in the file name (unittest-<fingerprint>-<hash>.json)

Reading:
- fix_unittests_issue now carries memory_files_content, and the unittest
  prompt template declares the variable. The field is optional server-side,
  so a client that predates this still validates and MIN_CLIENT_VERSION
  does not move
- the memory section sits after the template's cache breakpoint, since
  retrieved records change between attempts

Suite separation in retrieval:
- records from another surface rank below every same-surface match rather
  than being hidden. A unit-test failure and a conformance failure never
  share a fingerprint (different runners, different output), but they do
  share the files an intervention touched, and that is worth surfacing once
  the same-surface evidence runs out
- the prompt explains what scope.suite means and that the current surface's
  observations are the more relevant ones

One honest gap: unit-test fixes arrive as a single set of changed files with
no indication of which are implementation and which are unit tests, so the
intervention target is recorded as UNCLASSIFIED and the touched_* flags are
left undetermined. Deciding it from file paths would be a guess, and the
conformance path gets this for free from issue_reason_code. To keep "not
determined" distinct from a determined "no", those flags are now Optional
and default to None. This also means the test-weakening flag stays a
conformance-only signal -- which is right, since generated unit tests live
inside the module and editing them is normal rather than suspect.

Author: VitjanZ

codeplain_REST_api.py

@@ -233,6 +233,7 @@ def fix_unittests_issue(
         plain_source_tree,
         linked_resources,
         existing_files_content,
+        memory_files_content,
         module_name: str,
         required_modules,
         unittests_issue,
@@ -246,6 +247,7 @@ def fix_unittests_issue(
             "plain_source_tree": plain_source_tree,
             "linked_resources": linked_resources,
             "existing_files_content": existing_files_content,
+            "memory_files_content": memory_files_content,
             "module_name": module_name,
             "required_modules": required_modules,
             "unittests_issue": unittests_issue,

memory_management/record.py

@@ -55,6 +55,10 @@ class InterventionTarget(str, Enum):
     IMPLEMENTATION = "IMPLEMENTATION"
     CONFORMANCE_TESTS = "CONFORMANCE_TESTS"
     NONE = "NONE"
+    # The changed files are recorded, but which of them are implementation and which
+    # are tests is not known. Unit-test fixes land in one response with no such split,
+    # and classifying by file path would be a guess rather than an observation.
+    UNCLASSIFIED = "UNCLASSIFIED"
 
 
 class AttributionConfidence(str, Enum):
@@ -134,8 +138,9 @@ class Intervention:
     target: str
     files_changed: list[str] = field(default_factory=list)
     lines_changed: int = 0
-    touched_implementation: bool = False
-    touched_test_files: bool = False
+    # ``None`` means not determined, which is different from a determined ``False``.
+    touched_implementation: Optional[bool] = None
+    touched_test_files: Optional[bool] = None
 
     def signature(self) -> str:
         """Stable identity of this intervention, used to deduplicate records."""

memory_management/retrieval.py

@@ -30,6 +30,12 @@
 _DEPTH_BY_ATTEMPTS = ((0, 0), (2, 3), (5, 6))
 _MAX_DEPTH = 12
 
+# Records from a different test surface rank below every same-surface match. A unit-test
+# failure and a conformance failure never share a fingerprint (different runners, different
+# output), but they can share the files an intervention touched, which is worth surfacing
+# once the same-surface evidence is exhausted.
+_CROSS_SUITE_PENALTY = 10
+
 _BM25_K1 = 1.5
 _BM25_B = 0.75
 _TOKEN_PATTERN = re.compile(r"[a-z0-9_]+")
@@ -130,6 +136,7 @@ def rank_records(
     files_changed: Optional[Iterable[str]] = None,
     signature: Optional[str] = None,
     mode: MemoryMode = MemoryMode.ALL,
+    suite: Optional[str] = None,
 ) -> list[MemoryRecord]:
     """Order records by relevance to the failure currently being worked on."""
     allowed = _allowed_statuses(mode)
@@ -148,6 +155,8 @@ def rank_records(
                 continue
             # Lexical-only matches rank behind every symbolic match.
             tier = 4
+        if suite is not None and record.scope.suite != suite:
+            tier += _CROSS_SUITE_PENALTY
         # More occurrences means the observation repeated within this render, which is
         # independent evidence; ties break toward it.
         scored.append((tier, -lexical_score, -record.occurrences, record.memory_id, record))
@@ -164,6 +173,7 @@ def select_records(
     files_changed: Optional[Iterable[str]] = None,
     signature: Optional[str] = None,
     mode: MemoryMode = MemoryMode.ALL,
+    suite: Optional[str] = None,
 ) -> list[MemoryRecord]:
     """Rank, then cut to the adaptive depth."""
     if depth <= 0 or mode is MemoryMode.OFF:
@@ -176,5 +186,6 @@ def select_records(
         files_changed=files_changed,
         signature=signature,
         mode=mode,
+        suite=suite,
     )
     return ranked[:depth]

memory_management/store.py

@@ -68,6 +68,7 @@ def retrieve(
         files_changed: Optional[list[str]] = None,
         signature: Optional[str] = None,
         fix_attempts: int = 0,
+        suite: Optional[str] = None,
     ) -> dict[str, str]:
         """Select the records relevant to the current failure.
 
@@ -85,6 +86,7 @@ def retrieve(
             files_changed=files_changed,
             signature=signature,
             mode=self.memory_mode,
+            suite=suite,
         )
         if selected:
             console.debug(f"Retrieved {len(selected)} memory record(s) for the current failure.")

render_machine/actions/fix_conformance_test.py

@@ -67,7 +67,7 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
         existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
             render_context.build_folder
         )
-        memory_files_content = render_context.retrieve_memory_for_current_failure(previous_conformance_tests_issue)
+        memory_files_content = render_context.retrieve_memory_for_conformance_failure(previous_conformance_tests_issue)
         (
             existing_conformance_test_files,
             existing_conformance_test_files_content,

render_machine/actions/fix_unit_tests.py

@@ -1,12 +1,15 @@
 from typing import Any
 
+import diff_utils
 import file_utils
 import render_machine.render_utils as render_utils
+from memory_management import InterventionTarget
 from plain2code_console import console
 from plain2code_exceptions import InternalClientError
 from render_machine.actions.base_action import BaseAction
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
 from render_machine.render_context import RenderContext
+from render_machine.render_types import PendingIntervention
 
 MAX_ISSUE_LENGTH = 10000
 
@@ -32,11 +35,14 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
 
         render_utils.print_inputs(render_context, existing_files_content, "Files sent as input to unit tests fixing:")
 
+        memory_files_content = render_context.retrieve_memory_for_unittest_failure(previous_unittests_issue)
+
         response_files = render_context.codeplain_api.fix_unittests_issue(
             render_context.frid_context.frid,
             render_context.plain_source_tree,
             render_context.frid_context.linked_resources,
             existing_files_content,
+            memory_files_content,
             render_context.module_name,
             render_context.get_required_modules_functionalities(),
             previous_unittests_issue,
@@ -48,7 +54,31 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
         )
 
         render_context.unit_tests_running_context.changed_files.update(changed_files)
+        self._remember_intervention(render_context, response_files, existing_files_content, previous_unittests_issue)
 
         console.print_files("Files fixed:", render_context.build_folder, response_files, style=console.OUTPUT_STYLE)
 
         return self.SUCCESSFUL_OUTCOME, None
+
+    @staticmethod
+    def _remember_intervention(
+        render_context: RenderContext,
+        response_files: dict,
+        existing_files_content: dict,
+        failure_output: str,
+    ) -> None:
+        """Record what was just changed, to be paired with the next unit-test run's outcome.
+
+        The target is left unclassified: a unit-test fix arrives as one set of files with no
+        indication of which are implementation and which are tests, and deciding that from
+        file paths would be a guess rather than an observation.
+        """
+        code_diff_files = diff_utils.get_code_diff(response_files, existing_files_content)
+        running_context = render_context.unit_tests_running_context
+        running_context.pending_intervention = PendingIntervention(
+            attempt_index=running_context.fix_attempts,
+            target=InterventionTarget.UNCLASSIFIED.value,
+            files_changed=sorted(code_diff_files.keys()),
+            lines_changed=sum(len(diff.splitlines()) for diff in code_diff_files.values()),
+            failure_output=failure_output,
+        )

render_machine/actions/run_unit_tests.py

@@ -2,6 +2,7 @@
 from typing import Any
 
 import render_machine.render_utils as render_utils
+from memory_management import Failure, Intervention, Scope, Suite, fingerprint_output
 from plain2code_console import console
 from render_machine.actions.base_action import BaseAction
 from render_machine.render_context import RenderContext
@@ -31,6 +32,9 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
 
         render_context.script_execution_history.latest_unit_test_output_path = unittests_temp_log_file_path
         render_context.script_execution_history.should_update_script_outputs = True
+
+        self._record_observation(render_context, exit_code, unittests_issue)
+
         if exit_code == 0:
             return self.SUCCESSFUL_OUTCOME, None
 
@@ -48,3 +52,46 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
             )
         else:
             return self.FAILED_OUTCOME, {"previous_unittests_issue": unittests_issue}
+
+    @staticmethod
+    def _record_observation(render_context: RenderContext, exit_code: int, unittests_issue: str) -> None:
+        """Log what the fix applied before this run actually did.
+
+        Deterministic - no API call, no credit. Nothing is recorded until a fix has been
+        applied, because a record describes the effect of a change: the first failure of a
+        functionality is context the render already has.
+        """
+        running_context = render_context.unit_tests_running_context
+        if running_context is None or running_context.pending_intervention is None:
+            return
+
+        pending = running_context.pending_intervention
+        running_context.pending_intervention = None
+
+        fingerprint_before, signature_before, excerpt_before = fingerprint_output(pending.failure_output)
+        fingerprint_after, _, _ = fingerprint_output(unittests_issue if exit_code != 0 else None)
+
+        render_context.memory_store.record_observation(
+            scope=Scope(
+                module=render_context.module_name,
+                frid=render_context.frid_context.frid,
+                testing_module=render_context.module_name,
+                testing_frid=render_context.frid_context.frid,
+                suite=Suite.UNITTEST.value,
+            ),
+            failure=Failure(
+                fingerprint=fingerprint_before,
+                signature=signature_before,
+                excerpt=excerpt_before,
+                exit_code=1,
+            ),
+            intervention=Intervention(
+                attempt_index=pending.attempt_index,
+                target=pending.target,
+                files_changed=sorted(pending.files_changed),
+                lines_changed=pending.lines_changed,
+            ),
+            exit_code_after=exit_code,
+            fingerprint_after=fingerprint_after,
+            render_id=render_context.run_state.render_id,
+        )

render_machine/render_context.py

@@ -7,7 +7,7 @@
 import plain_spec
 from codeplain_REST_api import CodeplainAPI
 from event_bus import EventBus
-from memory_management import MemoryStore, fingerprint_output
+from memory_management import MemoryStore, Suite, fingerprint_output
 from plain2code_console import RETRY_COLOR, console
 from plain2code_events import RenderContextSnapshot
 from plain2code_state import RunState
@@ -123,29 +123,63 @@ def create_snapshot(self) -> RenderContextSnapshot:
             module_name=self.module_name,
         )
 
-    def retrieve_memory_for_current_failure(self, failure_output: Optional[str]) -> dict[str, str]:
-        """Select the memory records relevant to the failure currently being fixed.
+    def retrieve_memory_for_conformance_failure(self, failure_output: Optional[str]) -> dict[str, str]:
+        """Select memory records relevant to the conformance failure being fixed."""
+        running_context = self.conformance_tests_running_context
+
+        return self._retrieve_memory(
+            failure_output,
+            suite=Suite.CONFORMANCE.value,
+            test_name=(
+                running_context.get_current_conformance_test_folder_name()
+                if running_context and running_context.current_conformance_tests_exist()
+                else None
+            ),
+            fix_attempts=running_context.fix_attempts if running_context else 0,
+        )
 
-        The retrieval query comes entirely from render state - the failure being worked on,
-        the test that produced it, and how many fix attempts have been made - so no planner
-        call is needed. Retrieval depth grows with the attempt count: an early attempt gets
-        little or nothing, a deep fix loop gets the full picture.
+    def retrieve_memory_for_unittest_failure(self, failure_output: Optional[str]) -> dict[str, str]:
+        """Select memory records relevant to the unit-test failure being fixed.
+
+        Unit-test observations rank first; conformance observations can still surface once
+        the same-surface evidence is exhausted, since both loops change the same code.
+        """
+        running_context = self.unit_tests_running_context
+
+        return self._retrieve_memory(
+            failure_output,
+            suite=Suite.UNITTEST.value,
+            files_changed=sorted(running_context.changed_files) if running_context else None,
+            fix_attempts=running_context.fix_attempts if running_context else 0,
+        )
+
+    def _retrieve_memory(
+        self,
+        failure_output: Optional[str],
+        suite: str,
+        test_name: Optional[str] = None,
+        files_changed: Optional[list[str]] = None,
+        fix_attempts: int = 0,
+    ) -> dict[str, str]:
+        """Query the memory store for the failure currently being fixed.
+
+        The query comes entirely from render state - the failure being worked on, the test
+        that produced it, and how many fix attempts have been made - so no planner call is
+        needed. Depth grows with the attempt count: an early attempt gets little or nothing,
+        a deep fix loop gets the full picture.
         """
         if failure_output is None:
             return {}
 
         fingerprint, signature, _ = fingerprint_output(failure_output)
-        running_context = self.conformance_tests_running_context
 
         return self.memory_store.retrieve(
             fingerprint=fingerprint,
-            test_name=(
-                running_context.get_current_conformance_test_folder_name()
-                if running_context and running_context.current_conformance_tests_exist()
-                else None
-            ),
+            test_name=test_name,
+            files_changed=files_changed,
             signature=signature,
-            fix_attempts=running_context.fix_attempts if running_context else 0,
+            fix_attempts=fix_attempts,
+            suite=suite,
         )
 
     def get_required_modules_functionalities(self):

render_machine/render_types.py

@@ -73,6 +73,7 @@ class FridContext:
 class UnitTestsRunningContext:
     fix_attempts: int
     changed_files: set[str] = field(default_factory=set)
+    pending_intervention: Optional[PendingIntervention] = None
 
 
 class ConformanceTestsRunningContext: