codeplain 0.3.10.dev3__py3-none-any.whl → 0.3.10.dev5__py3-none-any.whl

render_machine/actions/fix_conformance_test.py

@@ -54,14 +54,13 @@ class FixConformanceTest(BaseAction):
             )
         previous_conformance_tests_issue = previous_action_payload["previous_conformance_tests_issue"]
 
-        render_context.conformance_tests_running_context.previous_conformance_tests_issue_old = (
-            previous_conformance_tests_issue
-        )
-        render_context.conformance_tests_running_context.previous_conformance_tests_issue_frid = (
-            render_context.conformance_tests_running_context.current_testing_frid
-        )
-        render_context.conformance_tests_running_context.previous_conformance_tests_issue_module = (
-            render_context.conformance_tests_running_context.current_testing_module_name
+        journal = render_context.memory_manager.journal
+        journal.record_result(ctx.current_testing_module_name, ctx.current_testing_frid, passed=False)
+        journal.open_attempt(
+            ctx.current_testing_module_name,
+            ctx.current_testing_frid,
+            ctx.fix_attempts,
+            previous_conformance_tests_issue,
         )
 
         existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
@@ -114,25 +113,28 @@ class FixConformanceTest(BaseAction):
             style=console.INPUT_STYLE,
         )
 
-        [issue_reason_code, response_files] = render_context.codeplain_api.fix_conformance_tests_issue(
-            render_context.frid_context.frid,
-            render_context.conformance_tests_running_context.current_testing_frid,
-            render_context.plain_source_tree,
-            render_context.frid_context.linked_resources,
-            existing_files_content,
-            memory_files_content,
-            render_context.module_name,
-            render_context.conformance_tests_running_context.current_testing_module_name,
-            render_context.get_required_modules_functionalities(),
-            previous_frid_code_diff,
-            existing_conformance_test_files_content,
-            render_context.conformance_tests_running_context.get_current_acceptance_tests(),
-            previous_conformance_tests_issue,
-            render_context.conformance_tests_running_context.fix_attempts,
-            render_context.conformance_tests_running_context.get_current_conformance_test_folder_name(),
-            render_context.conformance_tests_running_context.current_testing_frid_high_level_implementation_plan,
-            render_context.conformance_tests_running_context.conflicting_requirement_count,
-            run_state=render_context.run_state,
+        [issue_reason_code, response_files, fix_attempt_summary, prepared_conformance_tests_issue] = (
+            render_context.codeplain_api.fix_conformance_tests_issue(
+                render_context.frid_context.frid,
+                render_context.conformance_tests_running_context.current_testing_frid,
+                render_context.plain_source_tree,
+                render_context.frid_context.linked_resources,
+                existing_files_content,
+                memory_files_content,
+                render_context.module_name,
+                render_context.conformance_tests_running_context.current_testing_module_name,
+                render_context.get_required_modules_functionalities(),
+                previous_frid_code_diff,
+                existing_conformance_test_files_content,
+                render_context.conformance_tests_running_context.get_current_acceptance_tests(),
+                previous_conformance_tests_issue,
+                render_context.conformance_tests_running_context.fix_attempts,
+                render_context.conformance_tests_running_context.get_current_conformance_test_folder_name(),
+                render_context.conformance_tests_running_context.current_testing_frid_high_level_implementation_plan,
+                render_context.conformance_tests_running_context.conflicting_requirement_count,
+                journal.build_digest(ctx.current_testing_module_name, ctx.current_testing_frid),
+                run_state=render_context.run_state,
+            )
         )
         code_diff_files_content = {}
 
@@ -159,14 +161,21 @@ class FixConformanceTest(BaseAction):
                 existing_conformance_test_files,
             )
             code_diff_files_content = diff_utils.get_code_diff(response_files, existing_conformance_test_files_content)
-            render_context.conformance_tests_running_context.code_diff_files = code_diff_files_content
+            journal.record_fix(
+                ctx.current_testing_module_name,
+                ctx.current_testing_frid,
+                fix_attempt_summary,
+                list(response_files),
+                "CONFORMANCE_TESTS",
+                code_diff_files_content,
+                prepared_conformance_tests_issue,
+            )
 
             return self.IMPLEMENTATION_CODE_NOT_UPDATED, None
         else:
             if len(response_files) > 0:
                 file_utils.store_response_files(render_context.build_folder, response_files, existing_files)
                 code_diff_files_content = diff_utils.get_code_diff(response_files, existing_files_content)
-                render_context.conformance_tests_running_context.code_diff_files = code_diff_files_content
                 console.print_files(
                     "Files fixed:",
                     render_context.build_folder,
@@ -180,6 +189,26 @@ class FixConformanceTest(BaseAction):
                 ctx.test_that_triggered_code_change = (ctx.current_testing_module_name, ctx.current_testing_frid)
                 ctx.execution_phase = TestExecutionPhase.RETRYING_AFTER_CODE_CHANGE
 
+                journal.record_fix(
+                    ctx.current_testing_module_name,
+                    ctx.current_testing_frid,
+                    fix_attempt_summary,
+                    list(response_files),
+                    "IMPLEMENTATION_CODE",
+                    code_diff_files_content,
+                    prepared_conformance_tests_issue,
+                )
+
                 return self.IMPLEMENTATION_CODE_UPDATED, None
             else:
+                journal.record_fix(
+                    ctx.current_testing_module_name,
+                    ctx.current_testing_frid,
+                    fix_attempt_summary,
+                    [],
+                    "IMPLEMENTATION_CODE",
+                    None,
+                    prepared_conformance_tests_issue,
+                )
+
                 return self.IMPLEMENTATION_CODE_NOT_UPDATED, None

render_machine/actions/prepare_repositories.py

@@ -3,6 +3,7 @@ from typing import Any
 import file_utils
 import git_utils
 import plain_spec
+from memory_management import MemoryManager
 from plain2code_console import console
 from render_machine.actions.base_action import BaseAction
 from render_machine.render_context import RenderContext
@@ -50,6 +51,13 @@ class PrepareRepositories(BaseAction):
                     render_context.module_name,
                     render_context.run_state.render_id,
                 )
+
+                # Like the code repo, the distilled conformance test memories carry over from the
+                # previous module so its learnings are available while rendering this one.
+                MemoryManager.inherit_memories(
+                    previous_module.module_memory_folder,
+                    render_context.plain_module.module_memory_folder,
+                )
             else:
                 console.debug("Initializing git repositories for the render folders.")
 

render_machine/actions/run_conformance_tests.py

@@ -54,18 +54,12 @@ class RunConformanceTests(BaseAction):
         )
         render_context.script_execution_history.should_update_script_outputs = True
 
-        render_context.memory_manager.create_conformance_tests_memory(
-            render_context, exit_code, conformance_tests_issue
-        )
-
         if exit_code == 0:
-            if (
-                render_context.conformance_tests_running_context.current_testing_module_name
-                == render_context.module_name
-                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.journal.record_result(
+                render_context.conformance_tests_running_context.current_testing_module_name,
+                render_context.conformance_tests_running_context.current_testing_frid,
+                passed=True,
+            )
             return self.SUCCESSFUL_OUTCOME, None
 
         if exit_code in UNRECOVERABLE_ERROR_EXIT_CODES:

render_machine/render_types.py

@@ -90,10 +90,6 @@ class ConformanceTestsRunningContext:
         self.regenerating_conformance_tests: bool = False
 
         self.current_testing_frid_high_level_implementation_plan: Optional[str] = None
-        self.previous_conformance_tests_issue_old: Optional[str] = None
-        self.previous_conformance_tests_issue_frid: Optional[str] = None
-        self.previous_conformance_tests_issue_module: Optional[str] = None
-        self.code_diff_files: Optional[dict[str, str]] = None
 
     def get_conformance_tests_json(self, module_name: str) -> dict:
         return self._conformance_tests_json[module_name]

render_machine/state_machine_config.py

@@ -13,6 +13,7 @@ from render_machine.actions.analyze_specification_ambiguity import AnalyzeSpecif
 from render_machine.actions.commit_conformance_tests_changes import CommitConformanceTestsChanges
 from render_machine.actions.commit_implementation_code_changes import CommitImplementationCodeChanges
 from render_machine.actions.create_dist import CreateDist
+from render_machine.actions.distill_conformance_test_memory import DistillConformanceTestMemory
 from render_machine.actions.exit_with_error import ExitWithError
 from render_machine.actions.finish_functional_requirement import FinishFunctionalRequirement
 from render_machine.actions.fix_conformance_test import FixConformanceTest
@@ -52,6 +53,7 @@ class StateMachineConfig:
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TEST_GENERATED.value}": PrepareTestingEnvironment(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TEST_ENV_PREPARED.value}": RunConformanceTests(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TEST_FAILED.value}": FixConformanceTest(),
+            f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value}": DistillConformanceTestMemory(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value}": SummarizeConformanceTests(),
             f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_COMMIT.value}": CommitConformanceTestsChanges(
                 git_utils.CONFORMANCE_TESTS_PASSED_COMMIT_MESSAGE,
@@ -96,6 +98,7 @@ class StateMachineConfig:
             FixConformanceTest.REGENERATE_CONFORMANCE_TESTS_OUTCOME: triggers.MARK_REGENERATION_OF_CONFORMANCE_TESTS,
             CommitConformanceTestsChanges.SUCCESSFUL_OUTCOME_IMPLEMENTATION_UPDATED: triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
             CommitConformanceTestsChanges.SUCCESSFUL_OUTCOME_IMPLEMENTATION_NOT_UPDATED: triggers.PROCEED_FRID_PROCESSING,
+            DistillConformanceTestMemory.SUCCESSFUL_OUTCOME: triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
             SummarizeConformanceTests.SUCCESSFUL_OUTCOME: triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
             AnalyzeSpecificationAmbiguity.SUCCESSFUL_OUTCOME: triggers.PROCEED_FRID_PROCESSING,
         }
@@ -120,8 +123,9 @@ class StateMachineConfig:
     def get_postprocessing_conformance_tests_states(self) -> Dict[str, Any]:
         return {
             "name": States.POSTPROCESSING_CONFORMANCE_TESTS.value,
-            "initial": States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value,
+            "initial": States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value,
             "children": [
+                States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value,
                 States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value,
                 States.CONFORMANCE_TESTS_READY_FOR_COMMIT.value,
                 States.CONFORMANCE_TESTS_READY_FOR_AMBIGUITY_ANALYSIS.value,
@@ -278,6 +282,11 @@ class StateMachineConfig:
                 "trigger": triggers.MARK_ALL_CONFORMANCE_TESTS_PASSED,
                 "dest": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}",
             },
+            {
+                "source": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value}",
+                "trigger": triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,
+                "dest": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value}",
+            },
             {
                 "source": f"{States.IMPLEMENTING_FRID.value}_{States.PROCESSING_CONFORMANCE_TESTS.value}_{States.POSTPROCESSING_CONFORMANCE_TESTS.value}_{States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value}",
                 "trigger": triggers.MARK_NEXT_CONFORMANCE_TESTS_POSTPROCESSING_STEP,

render_machine/states.py

@@ -44,6 +44,7 @@ class States(Enum):
 
     # Postprocessing conformance tests states
     POSTPROCESSING_CONFORMANCE_TESTS = "postprocessingConformanceTests"
+    CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION = "conformanceTestsReadyForMemoryDistillation"
     CONFORMANCE_TESTS_READY_FOR_SUMMARY = "conformanceTestsReadyForSummary"
     CONFORMANCE_TESTS_READY_FOR_COMMIT = "conformanceTestsReadyForCommit"
     CONFORMANCE_TESTS_READY_FOR_AMBIGUITY_ANALYSIS = "conformanceTestsReadyForAmbiguityAnalysis"

tests/test_conformance_fix_journal.py

@@ -0,0 +1,259 @@
+"""Tests for the deterministic journal of conformance tests fix attempts."""
+
+import json
+import os
+import tempfile
+
+import pytest
+
+from conformance_fix_journal import MAX_ISSUE_EXCERPT_CHARS, FixAttemptJournal, normalized_diff_hash
+
+
+@pytest.fixture
+def memory_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        yield folder
+
+
+@pytest.fixture
+def journal(memory_folder):
+    return FixAttemptJournal(memory_folder)
+
+
+def record_full_attempt(
+    journal,
+    module="mod",
+    frid="1",
+    attempt=1,
+    diff=None,
+    summary=None,
+    files=None,
+    prepared_issue="prepared issue",
+):
+    journal.open_attempt(module, frid, attempt, "tests failed")
+    journal.record_fix(
+        module,
+        frid,
+        summary or {"hypothesis": f"hypothesis {attempt}", "approach": f"approach {attempt}"},
+        files if files is not None else ["src/app.py"],
+        "IMPLEMENTATION_CODE",
+        diff if diff is not None else {"src/app.py": f"diff {attempt}"},
+        prepared_issue,
+    )
+
+
+class TestNormalizedDiffHash:
+    def test_identical_diffs_hash_the_same(self):
+        diff = {"a.py": "+ line one\n+ line two"}
+
+        assert normalized_diff_hash(diff) == normalized_diff_hash(dict(diff))
+
+    def test_whitespace_only_differences_are_ignored(self):
+        assert normalized_diff_hash({"a.py": "+ line one\n\n  + line two  "}) == normalized_diff_hash(
+            {"a.py": "+ line one\n+ line two"}
+        )
+
+    def test_different_diffs_hash_differently(self):
+        assert normalized_diff_hash({"a.py": "+ line one"}) != normalized_diff_hash({"a.py": "+ line two"})
+
+    def test_empty_diff_has_no_hash(self):
+        assert normalized_diff_hash({}) is None
+        assert normalized_diff_hash(None) is None
+
+
+class TestJournalEntries:
+    def test_attempt_lifecycle_is_recorded(self, journal):
+        journal.open_attempt("mod", "1", 1, "raw failure output")
+        journal.record_fix(
+            "mod",
+            "1",
+            {"hypothesis": "the root cause", "approach": "the fix"},
+            ["src/app.py"],
+            "IMPLEMENTATION_CODE",
+            {"src/app.py": "diff"},
+            "the issue as the fixer saw it",
+        )
+        journal.record_result("mod", "1", passed=False)
+
+        [entry] = journal._read_entries("mod", "1")
+        assert entry["attempt"] == 1
+        assert entry["issue_before_raw"] == "raw failure output"
+        assert entry["issue_before"] == "the issue as the fixer saw it"
+        assert entry["hypothesis"] == "the root cause"
+        assert entry["approach"] == "the fix"
+        assert entry["files_changed"] == ["src/app.py"]
+        assert entry["target"] == "IMPLEMENTATION_CODE"
+        assert entry["result"] == "conformance tests still failed"
+
+    def test_raw_issue_is_stored_untruncated(self, journal):
+        long_issue = "x" * (MAX_ISSUE_EXCERPT_CHARS * 3) + "THE END"
+        journal.open_attempt("mod", "1", 1, long_issue)
+
+        [entry] = journal._read_entries("mod", "1")
+        assert entry["issue_before_raw"] == long_issue
+
+    def test_a_passing_result_is_recorded(self, journal):
+        record_full_attempt(journal)
+        journal.record_result("mod", "1", passed=True)
+
+        [entry] = journal._read_entries("mod", "1")
+        assert entry["result"] == "conformance tests passed"
+
+    def test_record_result_without_a_pending_attempt_does_nothing(self, journal):
+        journal.record_result("mod", "1", passed=False)
+
+        assert journal._read_entries("mod", "1") == []
+
+    def test_record_result_does_not_overwrite_a_completed_attempt(self, journal):
+        record_full_attempt(journal)
+        journal.record_result("mod", "1", passed=False)
+        journal.record_result("mod", "1", passed=True)
+
+        [entry] = journal._read_entries("mod", "1")
+        assert entry["result"] == "conformance tests still failed"
+
+    def test_missing_summary_and_prepared_issue_leave_the_entry_without_them(self, journal):
+        journal.open_attempt("mod", "1", 1, "failure")
+        journal.record_fix("mod", "1", None, ["src/app.py"], "IMPLEMENTATION_CODE", {"src/app.py": "diff"}, None)
+
+        [entry] = journal._read_entries("mod", "1")
+        assert "hypothesis" not in entry
+        assert "approach" not in entry
+        assert "issue_before" not in entry
+
+
+class TestDuplicateDetection:
+    def test_a_repeated_diff_is_marked_as_a_duplicate(self, journal):
+        diff = {"src/app.py": "+ same change"}
+        record_full_attempt(journal, attempt=1, diff=diff)
+        journal.record_result("mod", "1", passed=False)
+        record_full_attempt(journal, attempt=2, diff={"src/app.py": "+ same change  "})
+
+        entries = journal._read_entries("mod", "1")
+        assert "duplicate_of" not in entries[0]
+        assert entries[1]["duplicate_of"] == 1
+
+    def test_a_different_diff_is_not_marked(self, journal):
+        record_full_attempt(journal, attempt=1, diff={"src/app.py": "+ change one"})
+        journal.record_result("mod", "1", passed=False)
+        record_full_attempt(journal, attempt=2, diff={"src/app.py": "+ change two"})
+
+        entries = journal._read_entries("mod", "1")
+        assert "duplicate_of" not in entries[1]
+
+    def test_attempts_without_a_diff_are_never_duplicates(self, journal):
+        record_full_attempt(journal, attempt=1, diff={}, files=[])
+        journal.record_result("mod", "1", passed=False)
+        record_full_attempt(journal, attempt=2, diff={}, files=[])
+
+        entries = journal._read_entries("mod", "1")
+        assert "duplicate_of" not in entries[1]
+
+
+class TestDigest:
+    def test_digest_carries_the_compact_history_with_prepared_issues(self, journal):
+        record_full_attempt(journal, attempt=1, prepared_issue="issue as fixer saw it 1")
+        journal.record_result("mod", "1", passed=False)
+        record_full_attempt(journal, attempt=2, prepared_issue="issue as fixer saw it 2")
+
+        digest = journal.build_digest("mod", "1")
+
+        assert [entry["attempt"] for entry in digest] == [1, 2]
+        assert digest[0]["result"] == "conformance tests still failed"
+        assert digest[0]["hypothesis"] == "hypothesis 1"
+        assert digest[0]["issue"] == "issue as fixer saw it 1"
+        assert digest[1]["approach"] == "approach 2"
+        assert digest[1]["issue"] == "issue as fixer saw it 2"
+        for entry in digest:
+            assert "issue_before_raw" not in entry
+            assert "issue_before" not in entry
+            assert "diff_hash" not in entry
+
+    def test_digest_issue_is_capped(self, journal):
+        long_prepared = "x" * (MAX_ISSUE_EXCERPT_CHARS + 100) + "THE END"
+        record_full_attempt(journal, prepared_issue=long_prepared)
+
+        [entry] = journal.build_digest("mod", "1")
+        assert entry["issue"].endswith("THE END")
+        assert len(entry["issue"]) < len(long_prepared)
+
+    def test_digest_of_an_attempt_without_a_prepared_issue_has_no_issue(self, journal):
+        record_full_attempt(journal, prepared_issue=None)
+
+        [entry] = journal.build_digest("mod", "1")
+        assert "issue" not in entry
+
+    def test_the_open_attempt_is_excluded_from_the_digest(self, journal):
+        """The entry opened for the attempt about to be made carries nothing yet - the fixer must
+        not see an empty attempt in its history."""
+        record_full_attempt(journal, attempt=1)
+        journal.record_result("mod", "1", passed=False)
+        journal.open_attempt("mod", "1", 2, "current failure output")
+
+        digest = journal.build_digest("mod", "1")
+
+        assert [entry["attempt"] for entry in digest] == [1]
+
+    def test_a_dangling_attempt_without_a_fix_is_excluded_from_the_digest(self, journal):
+        """An interrupted render can leave an opened entry that later gets a result but never a fix."""
+        journal.open_attempt("mod", "1", 1, "failure output")
+        journal.record_result("mod", "1", passed=False)
+
+        assert journal.build_digest("mod", "1") == []
+
+    def test_digest_of_an_unknown_frid_is_empty(self, journal):
+        assert journal.build_digest("mod", "99") == []
+
+
+class TestCollectAndClear:
+    def test_collect_all_groups_by_module_and_frid(self, journal):
+        record_full_attempt(journal, module="mod", frid="1")
+        record_full_attempt(journal, module="other_module", frid="2.1")
+
+        journals = journal.collect_all()
+
+        assert [(j["module"], j["frid"]) for j in journals] == [("mod", "1"), ("other_module", "2.1")]
+        assert journals[0]["initial_issue"] == "prepared issue"
+        assert journals[0]["attempts"][0]["hypothesis"] == "hypothesis 1"
+
+    def test_initial_issue_falls_back_to_the_trimmed_raw_output(self, journal):
+        long_raw = "x" * (MAX_ISSUE_EXCERPT_CHARS + 100) + "THE END"
+        journal.open_attempt("mod", "1", 1, long_raw)
+        journal.record_fix("mod", "1", None, [], "IMPLEMENTATION_CODE", None, None)
+
+        [collected] = journal.collect_all()
+        assert collected["initial_issue"].endswith("THE END")
+        assert len(collected["initial_issue"]) < len(long_raw)
+
+    def test_module_names_containing_double_underscores_are_parsed(self, journal):
+        record_full_attempt(journal, module="my__module", frid="3")
+
+        [collected] = journal.collect_all()
+        assert collected["module"] == "my__module"
+        assert collected["frid"] == "3"
+
+    def test_collect_all_without_journals_is_empty(self, journal):
+        assert journal.collect_all() == []
+
+    def test_collect_all_skips_a_journal_holding_only_an_open_attempt(self, journal):
+        journal.open_attempt("mod", "1", 1, "failure output")
+
+        assert journal.collect_all() == []
+
+    def test_clear_all_removes_every_journal(self, journal):
+        record_full_attempt(journal, module="mod", frid="1")
+        record_full_attempt(journal, module="mod", frid="2")
+
+        journal.clear_all()
+
+        assert journal.collect_all() == []
+        assert not os.path.exists(journal.journal_folder)
+
+    def test_malformed_lines_are_skipped(self, journal, memory_folder):
+        record_full_attempt(journal)
+        with open(journal._journal_path("mod", "1"), "a") as journal_file:
+            journal_file.write("not json\n")
+            journal_file.write(json.dumps({"attempt": 2, "issue_before_raw": "x"}) + "\n")
+
+        entries = journal._read_entries("mod", "1")
+        assert [entry["attempt"] for entry in entries] == [1, 2]

tests/test_distill_conformance_test_memory.py

@@ -0,0 +1,145 @@
+"""Tests for the DistillConformanceTestMemory postprocessing action."""
+
+import json
+import os
+import tempfile
+from types import SimpleNamespace
+
+import pytest
+
+from memory_management import CONFORMANCE_TEST_MEMORY_SUBFOLDER, MemoryManager
+from render_machine.actions.distill_conformance_test_memory import DistillConformanceTestMemory
+
+
+class FakeCodeplainAPI:
+    def __init__(self, response_files=None, error=None):
+        self.response_files = response_files or {}
+        self.error = error
+        self.calls = []
+
+    def distill_conformance_test_memory(self, **kwargs):
+        self.calls.append(kwargs)
+        if self.error:
+            raise self.error
+        return self.response_files
+
+
+@pytest.fixture
+def build_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        yield folder
+
+
+@pytest.fixture
+def memory_folder():
+    with tempfile.TemporaryDirectory() as folder:
+        yield folder
+
+
+def make_render_context(api, memory_folder, build_folder):
+    memory_manager = MemoryManager(api, memory_folder)
+    return SimpleNamespace(
+        memory_manager=memory_manager,
+        codeplain_api=api,
+        build_folder=build_folder,
+        plain_source_tree={},
+        module_name="mod",
+        frid_context=SimpleNamespace(frid="1", linked_resources={}),
+        get_required_modules_functionalities=lambda: {},
+        run_state=SimpleNamespace(render_id="test-render-id"),
+    )
+
+
+def seed_journal(memory_manager, module="mod", frid="1"):
+    journal = memory_manager.journal
+    journal.open_attempt(module, frid, 1, "tests failed")
+    journal.record_fix(
+        module,
+        frid,
+        {"hypothesis": "root cause", "approach": "the fix"},
+        ["src/app.py"],
+        "IMPLEMENTATION_CODE",
+        {"src/app.py": "diff"},
+        "the issue as the fixer saw it",
+    )
+    journal.record_result(module, frid, passed=True)
+
+
+def test_no_journals_means_no_api_call(memory_folder, build_folder):
+    api = FakeCodeplainAPI()
+    render_context = make_render_context(api, memory_folder, build_folder)
+
+    outcome, payload = DistillConformanceTestMemory().execute(render_context, None)
+
+    assert outcome == DistillConformanceTestMemory.SUCCESSFUL_OUTCOME
+    assert payload is None
+    assert api.calls == []
+
+
+def test_journals_are_distilled_stored_and_cleared(memory_folder, build_folder):
+    memory_content = json.dumps({"memory_id": "learning-1", "key_learnings": "start the server first"})
+    api = FakeCodeplainAPI(response_files={"learning-1.json": memory_content})
+    render_context = make_render_context(api, memory_folder, build_folder)
+    seed_journal(render_context.memory_manager)
+
+    outcome, _ = DistillConformanceTestMemory().execute(render_context, None)
+
+    assert outcome == DistillConformanceTestMemory.SUCCESSFUL_OUTCOME
+    [call] = api.calls
+    assert call["frid"] == "1"
+    assert call["module_name"] == "mod"
+    assert call["fix_journals"][0]["module"] == "mod"
+    assert call["fix_journals"][0]["attempts"][0]["hypothesis"] == "root cause"
+
+    memory_file = os.path.join(memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER, "learning-1.json")
+    assert os.path.isfile(memory_file)
+    assert render_context.memory_manager.journal.collect_all() == []
+
+
+def test_a_delete_response_removes_an_existing_memory(memory_folder, build_folder):
+    memory_path = os.path.join(memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+    os.makedirs(memory_path)
+    with open(os.path.join(memory_path, "stale.json"), "w") as memory_file:
+        memory_file.write(json.dumps({"memory_id": "stale"}))
+
+    api = FakeCodeplainAPI(response_files={"stale.json": None})
+    render_context = make_render_context(api, memory_folder, build_folder)
+    seed_journal(render_context.memory_manager)
+
+    DistillConformanceTestMemory().execute(render_context, None)
+
+    assert not os.path.exists(os.path.join(memory_path, "stale.json"))
+
+
+def test_inherit_memories_copies_distilled_memories_but_not_journals(build_folder):
+    source_folder = os.path.join(build_folder, "previous_module", ".memory")
+    destination_folder = os.path.join(build_folder, "next_module", ".memory")
+    source_manager = MemoryManager(FakeCodeplainAPI(), source_folder)
+    seed_journal(source_manager)
+    source_manager.store_memory_files({"learning.json": json.dumps({"memory_id": "learning"})})
+
+    MemoryManager.inherit_memories(source_folder, destination_folder)
+
+    memory_files, _ = MemoryManager.fetch_memory_files(destination_folder)
+    assert memory_files == ["learning.json"]
+    assert MemoryManager(FakeCodeplainAPI(), destination_folder).journal.collect_all() == []
+
+
+def test_inherit_memories_from_a_module_without_memories_is_a_no_op(build_folder):
+    missing_source = os.path.join(build_folder, "does_not_exist", ".memory")
+    destination_folder = os.path.join(build_folder, "next_module", ".memory")
+
+    MemoryManager.inherit_memories(missing_source, destination_folder)
+
+    assert not os.path.exists(destination_folder)
+
+
+def test_an_api_failure_keeps_the_journals_and_does_not_raise(memory_folder, build_folder):
+    api = FakeCodeplainAPI(error=RuntimeError("api down"))
+    render_context = make_render_context(api, memory_folder, build_folder)
+    seed_journal(render_context.memory_manager)
+
+    outcome, _ = DistillConformanceTestMemory().execute(render_context, None)
+
+    assert outcome == DistillConformanceTestMemory.SUCCESSFUL_OUTCOME
+    assert len(render_context.memory_manager.journal.collect_all()) == 1