Keep every fix round, and let both test loops see the other's

The memory for a functionality was rebuilt after every conformance test run and the previous one deleted, so
a twenty round fix loop arrived at its last round remembering only the round the fixer can already see. It is
now two journals with two lifetimes. The functionality journal in `.memory/attempts/` gains one file per
round and touches no other, so what has been tried stays readable for the whole loop; global memory in
`.memory/global_memory.json` holds what transfers beyond the functionality that learned it, and is written
only by consolidation, which is the one place a recorded learning can be revised or retired.

Global memory is copied forward to the next module rather than shared between them. A shared file would let a
module inherit knowledge from its own future - re-render module three and it would read what modules four
onwards learned in a later render - so each module's copy is a snapshot of what the chain knew when it was
rendered, which keeps partial re-renders reproducible.

Unit test rounds go into the same journal as conformance rounds, and the unit test fixer is given the memory,
which it previously had none of. Inside a conformance fix loop it is also given the implementation changes
that loop just made: a unit test asserting the behaviour one of them replaced looks exactly like evidence
that the implementation is wrong, and repairing it there restores the conformance failure the change was made
to fix.

The journal is discarded when consolidation has taken what it needs from it, and again when a functionality
starts, since by then its rounds describe a problem nobody is working on any more.

Author: VitjanZ

CLAUDE.md

@@ -216,7 +216,9 @@ Two logging modes:
   - `<build-folder>/<module>/code/` — implementation code (its own git repo)
   - `<build-folder>/<module>/tests/` — conformance tests (its own git repo; only created when a conformance tests script is configured)
   - `<build-folder>/<module>/.codeplain/` — module metadata (`module_metadata.json`), not tracked in git
-  - `<build-folder>/<module>/.memory/` — conformance test memory, not tracked in git
+  - `<build-folder>/<module>/.memory/` — test-fixing memory, not tracked in git: `attempts/` holds the
+    current functionality's fix journal (one file per round, append-only), and `global_memory.json` holds
+    the condensed learnings, carried forward to the next module in the render chain
 - Each FRID render produces a git commit in the `code/` and `tests/` repos for rollback capability
 
 ### Configuration

codeplain_REST_api.py

@@ -236,6 +236,8 @@ def fix_unittests_issue(
         module_name: str,
         required_modules,
         unittests_issue,
+        memory_files_content,
+        conformance_fix_changes,
         run_state: RunState,
     ):
         endpoint_url = f"{self.api_url}/fix_unittests_issue"
@@ -250,6 +252,8 @@ def fix_unittests_issue(
             "required_modules": required_modules,
             "unittests_issue": unittests_issue,
             "unittest_batch_id": run_state.unittest_batch_id,
+            "memory_files_content": memory_files_content,
+            "conformance_fix_changes": conformance_fix_changes,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)
@@ -269,6 +273,8 @@ def create_conformance_test_memory(
         conformance_tests_issue,
         conformance_tests_folder_name,
         previous_conformance_tests_issue_old,
+        test_surface,
+        attempt_file_name,
         run_state: RunState,
     ):
         endpoint_url = f"{self.api_url}/create_conformance_test_memory"
@@ -288,6 +294,38 @@ def create_conformance_test_memory(
             "conformance_tests_issue": conformance_tests_issue,
             "conformance_tests_folder_name": conformance_tests_folder_name,
             "previous_conformance_tests_issue": previous_conformance_tests_issue_old,
+            "test_surface": test_surface,
+            "attempt_file_name": attempt_file_name,
+        }
+
+        return self.post_request(endpoint_url, headers, payload, run_state)
+
+    def consolidate_global_memory(
+        self,
+        frid,
+        plain_source_tree,
+        linked_resources,
+        memory_files_content,
+        module_name,
+        required_modules,
+        conformance_tests_files,
+        acceptance_tests,
+        conformance_tests_folder_name,
+        run_state: RunState,
+    ):
+        endpoint_url = f"{self.api_url}/consolidate_global_memory"
+        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
+
+        payload = {
+            "frid": frid,
+            "plain_source_tree": plain_source_tree,
+            "linked_resources": linked_resources,
+            "memory_files_content": memory_files_content,
+            "module_name": module_name,
+            "required_modules": required_modules,
+            "conformance_tests_files": conformance_tests_files,
+            "acceptance_tests": acceptance_tests,
+            "conformance_tests_folder_name": conformance_tests_folder_name,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)

memory_management.py

@@ -37,6 +37,23 @@ def __init__(
         self.stop_event = stop_event
         self.enter_pause_event = enter_pause_event
 
+    def _predecessor_memory_folder(self, plain_module: PlainModule) -> str | None:
+        """The memory folder of the module rendered immediately before this one, if there is one.
+
+        Taken from the module tree rather than from what has been rendered so far, so that the chain is the same
+        whether or not a module was skipped as unchanged: a skipped module's global memory is still on disk and
+        still belongs in the sequence.
+        """
+        ordered: list[PlainModule] = []
+        for module in plain_module.all_required_modules + [plain_module]:
+            if all(seen.module_name != module.module_name for seen in ordered):
+                ordered.append(module)
+
+        position = [module.module_name for module in ordered].index(plain_module.module_name)
+        if position == 0:
+            return None
+        return ordered[position - 1].module_memory_folder
+
     def _build_render_context_for_module(
         self,
         plain_module: PlainModule,
@@ -120,6 +137,7 @@ def _render_module(
         memory_manager = MemoryManager(
             self.codeplainAPI,
             plain_module.module_memory_folder,
+            self._predecessor_memory_folder(plain_module),
         )
         render_context = self._build_render_context_for_module(
             plain_module,

module_renderer.py

@@ -24,11 +24,7 @@
 import metadata_utils
 import plain_file
 import plain_spec
-from metadata_utils import (
-    MODULE_FUNCTIONALITIES,
-    MODULE_METADATA_FILENAME,
-    REQUIRED_MODULES_FUNCTIONALITIES,
-)
+from metadata_utils import MODULE_FUNCTIONALITIES, MODULE_METADATA_FILENAME, REQUIRED_MODULES_FUNCTIONALITIES
 from plain2code_console import console
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
 

plain_modules.py

@@ -1,7 +1,9 @@
 from typing import Any
 
+import diff_utils
 import file_utils
 import render_machine.render_utils as render_utils
+from memory_management import MemoryManager
 from plain2code_console import console
 from plain2code_exceptions import InternalClientError
 from render_machine.actions.base_action import BaseAction
@@ -14,6 +16,14 @@
 class FixUnitTests(BaseAction):
     SUCCESSFUL_OUTCOME = "unit_tests_fix_generated"
 
+    def __init__(self, inside_conformance_fix_loop: bool = False):
+        """``inside_conformance_fix_loop`` marks the instance that runs while :ConformanceTests: are being
+        fixed. There, the implementation has just been changed on purpose to make a conformance test pass, so a
+        unit test failing as a result is asserting behaviour that the change replaced - and repairing the
+        implementation restores the conformance failure. The two loops then trade the same lines back and
+        forth, neither able to see the other's history."""
+        self.inside_conformance_fix_loop = inside_conformance_fix_loop
+
     def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
         if not previous_action_payload.get("previous_unittests_issue"):
             raise InternalClientError(
@@ -32,6 +42,12 @@ 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 = MemoryManager.fetch_memory_files(render_context.memory_manager.memory_folder)
+
+        conformance_fix_changes = None
+        if self.inside_conformance_fix_loop:
+            conformance_fix_changes = render_context.conformance_tests_running_context.code_diff_files
+
         response_files = render_context.codeplain_api.fix_unittests_issue(
             render_context.frid_context.frid,
             render_context.plain_source_tree,
@@ -40,6 +56,8 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
             render_context.module_name,
             render_context.get_required_modules_functionalities(),
             previous_unittests_issue,
+            memory_files_content,
+            conformance_fix_changes,
             run_state=render_context.run_state,
         )
 
@@ -49,6 +67,12 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
 
         render_context.unit_tests_running_context.changed_files.update(changed_files)
 
+        # Held for the next unit test run to record: the failure this round answered, and what it changed.
+        render_context.unit_tests_running_context.previous_unittests_issue = previous_unittests_issue
+        render_context.unit_tests_running_context.code_diff_files = diff_utils.get_code_diff(
+            response_files, existing_files_content
+        )
+
         console.print_files("Files fixed:", render_context.build_folder, response_files, style=console.OUTPUT_STYLE)
 
         return self.SUCCESSFUL_OUTCOME, None

render_machine/actions/fix_unit_tests.py

@@ -40,6 +40,10 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
             file_utils.delete_folder(render_context.plain_module.module_folder)
             render_context.plain_module.seed_module_metadata()
 
+            # After the wipe, not before it: the module folder that was just deleted holds .memory, so global
+            # memory has to be carried forward once there is somewhere for it to live.
+            render_context.memory_manager.inherit_global_memory()
+
             if render_context.required_modules:
                 previous_module = render_context.required_modules[-1]
                 console.debug(f"Cloning git repo from module {previous_module.module_name}.")

render_machine/actions/prepare_repositories.py

@@ -54,7 +54,7 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
         )
         render_context.script_execution_history.should_update_script_outputs = True
 
-        render_context.memory_manager.create_conformance_tests_memory(
+        render_context.memory_manager.record_conformance_test_fix_attempt(
             render_context, exit_code, conformance_tests_issue
         )
 
@@ -65,7 +65,7 @@ def execute(self, render_context: RenderContext, _previous_action_payload: Any |
                 and render_context.conformance_tests_running_context.current_testing_frid
                 == render_context.frid_context.frid
             ):
-                render_context.memory_manager.delete_unresolved_memory_files()
+                render_context.memory_manager.consolidate_global_memory(render_context)
             return self.SUCCESSFUL_OUTCOME, None
 
         if exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:

render_machine/actions/run_conformance_tests.py

@@ -31,6 +31,10 @@ 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
+
+        # Recorded here rather than where the fix was made, because only now is the outcome of that fix known.
+        render_context.memory_manager.record_unit_test_fix_attempt(render_context, exit_code, unittests_issue)
+
         if exit_code == 0:
             return self.SUCCESSFUL_OUTCOME, None
 

render_machine/actions/run_unit_tests.py

@@ -169,6 +169,11 @@ def start_implementing_frid(self):
             functional_requirement_render_attempts=0,
         )
         self.run_state.current_frid = frid
+
+        # The journal describes rounds of fixing the previous functionality's tests. Those rounds are about a
+        # problem that is no longer the one being worked on, and anything durable in them has already been
+        # consolidated into global memory.
+        self.memory_manager.clear_functionality_journal()
         return
 
     def has_next_frid(self) -> bool: