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

{codeplain-0.3.10.dev3.dist-info → codeplain-0.3.10.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.10.dev3
+Version: 0.3.10.dev4
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

{codeplain-0.3.10.dev3.dist-info → codeplain-0.3.10.dev4.dist-info}/RECORD

@@ -1,11 +1,12 @@
 change_detection.py,sha256=CazORZrezeZSw2I6VBvieN-c2SEjieZPo6pNrKwmMVA,6915
-codeplain_REST_api.py,sha256=x-sCbbBSswID4eKXDMvv84nzWynNSbBPoyAtq__6tas,21644
+codeplain_REST_api.py,sha256=Iu3htCE05k-8BOA6I2acz4Ezr74cHQIXmhBIsgnX4Ng,21232
 concept_utils.py,sha256=TpyiQ4DfMtO231j-lPj65i0suRTPr8t9j3QNf9KiM4A,8080
+conformance_fix_journal.py,sha256=7wL3UOc3BWaUo5MCmiFbb3kIwOQ6iEpdQSyEmedo8Vk,9488
 diff_utils.py,sha256=AjiQlqo5pRos_8hVXZo5yBurl5BzSrTMGrQv4dCtRCg,1198
 event_bus.py,sha256=g5XLwRfjrvTIcB6urjREuCJzZj5TA93hy8lKXLGXuCE,650
 file_utils.py,sha256=MNZ5li1ofIMOYB6FCrMa_UkX6nkGCgSZuaqzhqVc1Ok,11682
 git_utils.py,sha256=gCUA6_9zg19f6k_0aVcRnIVlAJSBD0Vt6takx-0pKME,16547
-memory_management.py,sha256=SPoK0BXB9_yDyrrOKjFtOOlKkJIq0I5EXV7dE0OsE8g,5972
+memory_management.py,sha256=CwIOQqF7Xo1sNfvP69zQRK_CpjinQD9dbolhRPl6lTk,2446
 metadata_utils.py,sha256=YO17o7IAma5TT1ZN0pTwrLVr_KxFQ8APv02KqKPpI5k,1641
 module_renderer.py,sha256=IJBle8mbBARn_xrekjSpsVID7719yy2rNPkM15-ONoI,6982
 partial_rendering.py,sha256=uzZc2j4d3pAXzfiHw_y1TK4yLRsLOb1Mm21570AGxJ8,13837
@@ -39,26 +40,27 @@ render_machine/code_renderer.py,sha256=-vp_ltU7e3ssX9hbS8IY4ETSp-39JAuoJ3ZltKpdt
 render_machine/conformance_tests.py,sha256=PNTCnJNd_xNIhpTPPS8vlx8qws3cTgQSTLdADRab2YM,9617
 render_machine/implementation_code_helpers.py,sha256=Fxm-IInoZjAIZn41_-WXWj7VIYczpW4yH44Gt8CYMAQ,2378
 render_machine/render_context.py,sha256=iaJWI_EMSn51LNF_b7KRvlir46ZgUkjbaEiVgSvMTCI,26314
-render_machine/render_types.py,sha256=cT3D0lmxQ3enIo0jGp3LEGCY2t3X1Q1_tqwcadzSAv0,8761
+render_machine/render_types.py,sha256=IY16mGnt5uoZlLKy16Wmpq0_M5PAitVDvt2khnDhKU0,8479
 render_machine/render_utils.py,sha256=yA3X15E_Lebk_-MxkSz9rM_qy-Pes8EQ9Ye-smkHCDw,9320
-render_machine/state_machine_config.py,sha256=NnX5sBGkc6cNG8OOQ4PrJeJBCADRGZKJYQXV7ndR4bs,26789
-render_machine/states.py,sha256=niFXqayyA_rezCrlzo0hYeHAruErcPzQVF-BeIBGnL8,1968
+render_machine/state_machine_config.py,sha256=0pL4PyrZ5F2UumvHLMRfhyh64M4pDvf-9zEs-5OAEU8,27866
+render_machine/states.py,sha256=Lu-7upbs9_bjJsy0P738qx5IiN0DzVcFdhF2-m6YjnQ,2067
 render_machine/triggers.py,sha256=VekNhHGR-u5JXIboqc_Eyqf73LNH7wezLK7r3WWtodk,1269
 render_machine/actions/analyze_specification_ambiguity.py,sha256=SykZAozGvr1jySxbpKCgt11nMpZhOK0sN-J66M42T5Y,2847
 render_machine/actions/base_action.py,sha256=vVzMp-LanrZyq-jamHyWaQxpRl-pLqtTdtiEzUBhfyE,534
 render_machine/actions/commit_conformance_tests_changes.py,sha256=08yxCPCpf5TlrzLPsEh5SJXVVvnLfwdNKSr7BlzlYxo,2589
 render_machine/actions/commit_implementation_code_changes.py,sha256=yi51oAArLCgWcmFbynes-BK2IGnZwA7wygrTJGoL8dY,826
 render_machine/actions/create_dist.py,sha256=ykER7i2OvWAXjrlAZnkQHpiNl00vSMF8WDxNhlWKfsA,1088
+render_machine/actions/distill_conformance_test_memory.py,sha256=ENjfhTWqRLePHeRF4t8zNRhWKDV2rU4pLYuU_CZhhmo,2639
 render_machine/actions/exit_with_error.py,sha256=W6TMULHJcHEaXE4WUnlELEu0_l7IZy9HWaPkXyqg7ck,1279
 render_machine/actions/finish_functional_requirement.py,sha256=usQgPSg6PHpBOR1RhK7lPz9zjY-2VJJDqi3T0nlqdLw,841
-render_machine/actions/fix_conformance_test.py,sha256=EZLVjF4A8zSTmyqdgcLoz-2pLpeieq4M_Rb71pY3IKA,10095
+render_machine/actions/fix_conformance_test.py,sha256=mHk-UJNEZ7Y65YLLUBljJ3Z5zBVA4jIYRSJ0VCd_LOw,11012
 render_machine/actions/fix_unit_tests.py,sha256=hvwvCJDk_-8fHMpkNFyeBSG1IshIcufDpymF00ulPXY,2301
-render_machine/actions/prepare_repositories.py,sha256=8poItxPrUZWKCFReqdAKL__bxjM71Ig2zLkg1TDGmpY,3439
+render_machine/actions/prepare_repositories.py,sha256=HyZ1R6E3H5V-G4WDSGfhxl_arskmW9FcaxNdQr6JjVs,3867
 render_machine/actions/prepare_testing_environment.py,sha256=kIsXgV6-jOlqp-04cimPgTQoHPrVIu0zW-H_Jj-jowE,2106
 render_machine/actions/refactor_code.py,sha256=gyPsnqgHseL2bkENu4WeGCRyV0R18_GH3JOrPdoxKvg,2609
 render_machine/actions/render_conformance_tests.py,sha256=5gOQn-G1T9UWEI8sDfALcVdArk0ln9DgUprOPjccS-U,9268
 render_machine/actions/render_functional_requirement.py,sha256=53KzMVlcefoag1x73roCEQvQ7FbmH8FzhXMQau-s8tg,4655
-render_machine/actions/run_conformance_tests.py,sha256=4sJTORl6YLFXQIdLMBQHDeJd2hztGyt3tsVvrCviBko,4008
+render_machine/actions/run_conformance_tests.py,sha256=yUG6buqp75EOmJYxdM6MmCNF5_G4TUxA-QSTKx7EzxA,3760
 render_machine/actions/run_unit_tests.py,sha256=A4WXtSzpCLDHYR8fQAbfxUf_E19GYflZSHZaSreoFPk,2101
 render_machine/actions/summarize_conformance_tests.py,sha256=Vy1kRK8vyazK_BbsKuz1MLDN_TQWVxxzkwEEm-50byc,1639
 standard_template_library/golang-console-app-template.plain,sha256=JOusEjCj7jagnXUzaI-SdIr3hj1wTo2uShK017aNtVM,949
@@ -70,7 +72,9 @@ tests/conftest.py,sha256=QZcp08htUlJGgmHDlRWFgsWXZ8o8IBWTD5QqJaUMlU8,790
 tests/test_arg_provenance.py,sha256=d_J7aCeHMXBpctBWTt60WU-I8pEKN7XRXRTJZZGCdo0,3441
 tests/test_change_detection.py,sha256=jH8SEhndX400DNqIKmcYLzxHqq9WFdgmuvY3XPq-ZFc,13534
 tests/test_cli_output.py,sha256=ZV2F1NNW4EiZvMNkhF9XUZH6bFJbddfkZof5qAFxe3Y,18885
+tests/test_conformance_fix_journal.py,sha256=olTeAuxXgFwQ8LSQyt0FqtBy9_XY_gK-Ei_pUuJ0C3M,10389
 tests/test_console_log_styles.py,sha256=63DQWiwWNhe_rMP70bW9DAB6-EPaqU3Wpwyh8eR09pc,4080
+tests/test_distill_conformance_test_memory.py,sha256=Tftw9l-gLVwIU6QttY03h2VedvuFxpIsCmZIzvWfxMA,5481
 tests/test_file_utils.py,sha256=R_ZIhrTtwlhHxgmbBtA8PFEU5-QB4Fi5skJ7PS2KzdU,3614
 tests/test_folder_path_resolution.py,sha256=K9v684xkPE0HOAsovg8uDixpZmaIk7ho-Wd3rTjKLF0,6560
 tests/test_git_utils.py,sha256=h3rWhhs4XVRYqzVzdmj51siF_AYD-GkbZiefK2iGfWo,15614
@@ -87,7 +91,7 @@ tests/test_plain_modules.py,sha256=Fn3FeH-M4exnyFJDZzc9YWaLEfBmiqPH5TpiBT9jgAs,3
 tests/test_plainfile.py,sha256=wZ_PN4GULPWIpl_AK_r_6jkgtX0Ch8EHmN5IhX7huOE,11027
 tests/test_plainfileparser.py,sha256=l8GfXkVaSzgH74fX45Wp5jX0q3QlO6t_TgDG72dc28o,23867
 tests/test_plainspec.py,sha256=ng55E8ajrH2-gPC1p_QDIe_zXplPvoqHJ-d57UWKFTw,3577
-tests/test_prepare_repositories_layout.py,sha256=iHDfZi2OFLDp4SyjR9o11imKKiTGzycb_1nWBkW7QFE,12515
+tests/test_prepare_repositories_layout.py,sha256=PhJQLnHfjfjo6CTWoicyEKgL0_GtjwB2OKYAWSBVHtk,14638
 tests/test_requires.py,sha256=6tnHYaKudxN-RiQjSFoi9nHe_x0ze3QF-f-j67zAE74,1250
 tests/test_resolve_config_file.py,sha256=b87tDOvyzbsnE-QRWbZ97ou7NuyaAgskv-dbYBum31c,2830
 tests/test_script_path_resolution.py,sha256=tiEqMevQRXr9YpfHN0xldOOQpLAUgnSqTzeZWkKHaUY,4156
@@ -104,11 +108,11 @@ tui/models.py,sha256=KMjlWubmPD41GA-BjgiqkaV9v7tLJ0fuWKBDPmZj4JA,1493
 tui/plain2code_tui.py,sha256=8F7ZYRpmTiWRdTeQ63LPf2LGrreYjIYXvf_9XNSPyHs,17104
 tui/plain_module_render_choice_tui.py,sha256=XwBMMzyDat9FYqMkKdIV7kmIevddfwGA5Qk9kgy5sYY,12112
 tui/spinner.py,sha256=Ro6Gd9Przf-whuHqPRY6HwI0T57yJjyNPbhDbigZKZE,2471
-tui/state_handlers.py,sha256=4r_6m5YMcprQtgiTP0De3XFfGAF8VzgaWXHxPweYPbQ,16325
+tui/state_handlers.py,sha256=zbUS_D9eU8qIwVpaxPEp9zL9bpg8gXsWNoUaqg9TLrQ,16664
 tui/styles.css,sha256=kiC7Og_2G1E7owoiZgV95-3_dSeQnsNj3qzaY04xkDg,6727
 tui/widget_helpers.py,sha256=ToO9MV2bF2Rp-XMNcjIYclnB_qmgO5sLw4UtQ2CyTMg,6652
-codeplain-0.3.10.dev3.dist-info/METADATA,sha256=BQ2CP4ur9t4LBdTGsYW7aJncruH-tL-sPRpHX_vpMAA,7256
-codeplain-0.3.10.dev3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-codeplain-0.3.10.dev3.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
-codeplain-0.3.10.dev3.dist-info/licenses/LICENSE,sha256=pCeKgQ1mXE5OmNUuKOfOZh1T1vqkeCUxghE7N8qgnzc,11345
-codeplain-0.3.10.dev3.dist-info/RECORD,,
+codeplain-0.3.10.dev4.dist-info/METADATA,sha256=AHNwzkViIw83FQTt9C5UKXgVVALnEwJ3li-gXTzaUxU,7256
+codeplain-0.3.10.dev4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+codeplain-0.3.10.dev4.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
+codeplain-0.3.10.dev4.dist-info/licenses/LICENSE,sha256=pCeKgQ1mXE5OmNUuKOfOZh1T1vqkeCUxghE7N8qgnzc,11345
+codeplain-0.3.10.dev4.dist-info/RECORD,,

codeplain_REST_api.py

@@ -254,7 +254,7 @@ class CodeplainAPI:
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
-    def create_conformance_test_memory(
+    def distill_conformance_test_memory(
         self,
         frid,
         plain_source_tree,
@@ -263,15 +263,10 @@ class CodeplainAPI:
         memory_files_content,
         module_name,
         required_modules,
-        code_diff,
-        conformance_tests_files,
-        acceptance_tests,
-        conformance_tests_issue,
-        conformance_tests_folder_name,
-        previous_conformance_tests_issue_old,
+        fix_journals,
         run_state: RunState,
     ):
-        endpoint_url = f"{self.api_url}/create_conformance_test_memory"
+        endpoint_url = f"{self.api_url}/distill_conformance_test_memory"
         headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
 
         payload = {
@@ -282,12 +277,7 @@ class CodeplainAPI:
             "memory_files_content": memory_files_content,
             "module_name": module_name,
             "required_modules": required_modules,
-            "code_diff": code_diff,
-            "conformance_tests_files": conformance_tests_files,
-            "acceptance_tests": acceptance_tests,
-            "conformance_tests_issue": conformance_tests_issue,
-            "conformance_tests_folder_name": conformance_tests_folder_name,
-            "previous_conformance_tests_issue": previous_conformance_tests_issue_old,
+            "fix_journals": fix_journals,
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)
@@ -381,6 +371,7 @@ class CodeplainAPI:
         conformance_tests_folder_name,
         current_testing_frid_high_level_implementation_plan: Optional[str],
         conflicting_requirements_count: int,
+        fix_attempts_journal: list,
         run_state: RunState,
     ):
         endpoint_url = f"{self.api_url}/fix_conformance_tests_issue"
@@ -403,6 +394,7 @@ class CodeplainAPI:
             "conformance_tests_folder_name": conformance_tests_folder_name,
             "current_testing_frid_high_level_implementation_plan": current_testing_frid_high_level_implementation_plan,
             "conflicting_requirements_count": conflicting_requirements_count,
+            "fix_attempts_journal": fix_attempts_journal,
         }
 
         if acceptance_tests is not None:

conformance_fix_journal.py

@@ -0,0 +1,207 @@
+"""Deterministic journal of conformance tests fix attempts.
+
+While a functionality's conformance tests are failing, every fix attempt is recorded here: the
+issue that triggered it, what the fixer said it tried, which files it changed and whether the tests
+passed afterwards. A digest of the journal is sent back with every fix request so the fixer does
+not repeat attempts that already failed, and once the functionality's conformance tests all pass
+the journal is distilled into durable memories and deleted.
+
+Each entry carries the issue in two forms: the raw script output (kept untruncated, on disk only)
+and the prepared form the server built for the fix prompt (trimmed, and summarized or truncated
+when oversized) - the issue exactly the way the fixer saw it. The prepared form is what travels in
+the fix digest and the distillation payload; the raw form exists for humans debugging a render.
+An attempt's outcome text is not stored twice: the output produced after an attempt is the raw
+issue of the next attempt.
+
+Journals are keyed by the (module, frid) whose tests are being fixed - during the regression sweep
+that can be a previously implemented functionality, possibly from a required module.
+"""
+
+import hashlib
+import json
+import os
+import shutil
+
+from plain2code_console import console
+
+CONFORMANCE_TEST_JOURNAL_SUBFOLDER = "conformance_test_journal"
+
+# Cap for the issue excerpts included in payloads (the per-attempt issue in the fix digest, and the
+# initial issue in the distillation payload). The server-prepared issue is already bounded (LLM
+# summary or ~10k-char truncation), so this only trims the rare oversized case - it must not
+# routinely cut into summaries the server already sized for a prompt.
+MAX_ISSUE_EXCERPT_CHARS = 8000
+
+# The keys of a journal entry that make up the digest sent to the fixer and the distiller.
+DIGEST_KEYS = ["attempt", "hypothesis", "approach", "target", "files_changed", "duplicate_of", "result"]
+
+
+def _trim_issue(issue: str | None, max_chars: int) -> str | None:
+    if issue is None or len(issue) <= max_chars:
+        return issue
+    return f"(TRUNCATED - showing the last {max_chars} characters)\n" + issue[-max_chars:]
+
+
+def normalized_diff_hash(diff_files: dict[str, str] | None) -> str | None:
+    """Hashes a fix's diff so that essentially identical retries can be detected.
+
+    Whitespace-only differences are ignored - a fix that reproduces an earlier failed change with
+    different formatting is still the same attempt.
+    """
+    if not diff_files:
+        return None
+
+    normalized_parts = []
+    for file_name in sorted(diff_files):
+        content_lines = [line.strip() for line in (diff_files[file_name] or "").splitlines() if line.strip()]
+        normalized_parts.append(file_name + "\n" + "\n".join(content_lines))
+
+    return hashlib.sha256("\n".join(normalized_parts).encode("utf-8")).hexdigest()
+
+
+class FixAttemptJournal:
+    """File-backed journal, one JSONL file per (module, frid) whose conformance tests are fixed."""
+
+    def __init__(self, memory_folder: str):
+        self.journal_folder = os.path.join(memory_folder, CONFORMANCE_TEST_JOURNAL_SUBFOLDER)
+
+    def _journal_path(self, module_name: str, frid: str) -> str:
+        return os.path.join(self.journal_folder, f"{module_name}__{frid}.jsonl")
+
+    def _read_entries(self, module_name: str, frid: str) -> list[dict]:
+        journal_path = self._journal_path(module_name, frid)
+        if not os.path.exists(journal_path):
+            return []
+
+        entries = []
+        with open(journal_path, "r", encoding="utf-8") as journal_file:
+            for line in journal_file:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    console.error(f"Skipping malformed journal entry in {journal_path}.")
+
+        return entries
+
+    def _write_entries(self, module_name: str, frid: str, entries: list[dict]):
+        os.makedirs(self.journal_folder, exist_ok=True)
+        with open(self._journal_path(module_name, frid), "w", encoding="utf-8") as journal_file:
+            for entry in entries:
+                journal_file.write(json.dumps(entry) + "\n")
+
+    def open_attempt(self, module_name: str, frid: str, attempt_no: int, issue_before: str):
+        """Starts a new journal entry for a fix attempt that is about to be made.
+
+        The raw issue is stored untruncated - it never travels in a payload, only its prepared form
+        (recorded later by record_fix) does.
+        """
+        entries = self._read_entries(module_name, frid)
+        entries.append({"attempt": attempt_no, "issue_before_raw": issue_before})
+        self._write_entries(module_name, frid, entries)
+
+    def record_fix(
+        self,
+        module_name: str,
+        frid: str,
+        fix_attempt_summary: dict | None,
+        files_changed: list[str],
+        target: str,
+        diff_files: dict[str, str] | None,
+        prepared_issue: str | None,
+    ):
+        """Completes the open attempt with what the fix actually did.
+
+        The prepared issue is the form the server built for the fix prompt - the issue exactly the
+        way the fixer saw it. The diff hash marks the attempt as a duplicate when an earlier attempt
+        in the same journal produced essentially the same change - the strongest signal that the
+        fixer is going in circles.
+        """
+        entries = self._read_entries(module_name, frid)
+        if not entries:
+            console.error("Cannot record a fix - no journal entry is open.")
+            return
+
+        entry = entries[-1]
+        if isinstance(fix_attempt_summary, dict):
+            entry["hypothesis"] = fix_attempt_summary.get("hypothesis")
+            entry["approach"] = fix_attempt_summary.get("approach")
+        if prepared_issue:
+            entry["issue_before"] = prepared_issue
+        entry["files_changed"] = sorted(files_changed)
+        entry["target"] = target
+
+        diff_hash = normalized_diff_hash(diff_files)
+        entry["diff_hash"] = diff_hash
+        if diff_hash is not None:
+            for earlier_entry in entries[:-1]:
+                if earlier_entry.get("diff_hash") == diff_hash:
+                    entry["duplicate_of"] = earlier_entry["attempt"]
+                    break
+
+        self._write_entries(module_name, frid, entries)
+
+    def record_result(self, module_name: str, frid: str, passed: bool):
+        """Records whether the conformance tests passed after the last fix attempt was applied.
+
+        A failed run's output is not stored here - it becomes the raw issue of the next attempt.
+        Does nothing when no attempt is pending: the first test run of a functionality has no fix
+        attempt behind it.
+        """
+        entries = self._read_entries(module_name, frid)
+        if not entries or "result" in entries[-1]:
+            return
+
+        entries[-1]["result"] = "conformance tests passed" if passed else "conformance tests still failed"
+        self._write_entries(module_name, frid, entries)
+
+    def build_digest(self, module_name: str, frid: str) -> list[dict]:
+        """Builds the compact attempt history sent with a fix request.
+
+        Only attempts whose fix has been recorded are included - the entry just opened for the
+        attempt being made (and any dangling entry an interrupted render left behind) carries no
+        information for the fixer. Each included attempt carries the prepared issue it addressed,
+        so the fixer can see how the issue evolved across attempts. Raw outputs never travel - the
+        current issue is sent with the request separately.
+        """
+        return [self._digest_entry(entry) for entry in self._read_entries(module_name, frid) if "target" in entry]
+
+    @staticmethod
+    def _digest_entry(entry: dict) -> dict:
+        digest_entry = {key: entry[key] for key in DIGEST_KEYS if key in entry}
+        if entry.get("issue_before"):
+            digest_entry["issue"] = _trim_issue(entry["issue_before"], MAX_ISSUE_EXCERPT_CHARS)
+        return digest_entry
+
+    def collect_all(self) -> list[dict]:
+        """Collects the digests of every journal, keyed by the tested module and frid, for distillation."""
+        if not os.path.exists(self.journal_folder):
+            return []
+
+        journals = []
+        for file_name in sorted(os.listdir(self.journal_folder)):
+            if not file_name.endswith(".jsonl") or "__" not in file_name:
+                continue
+            module_name, _, frid = file_name[: -len(".jsonl")].rpartition("__")
+            entries = [entry for entry in self._read_entries(module_name, frid) if "target" in entry]
+            if not entries:
+                continue
+            initial_issue = entries[0].get("issue_before") or _trim_issue(
+                entries[0].get("issue_before_raw"), MAX_ISSUE_EXCERPT_CHARS
+            )
+            journal = {
+                "module": module_name,
+                "frid": frid,
+                "initial_issue": initial_issue,
+                "attempts": [self._digest_entry(entry) for entry in entries],
+            }
+            journals.append(journal)
+
+        return journals
+
+    def clear_all(self):
+        """Deletes every journal. Called after the journals have been distilled into memories."""
+        if os.path.exists(self.journal_folder):
+            shutil.rmtree(self.journal_folder)

memory_management.py

@@ -1,16 +1,18 @@
-import json
 import os
 
 import file_utils
+from conformance_fix_journal import FixAttemptJournal
 from plain2code_console import console
-from render_machine.implementation_code_helpers import ImplementationCodeHelpers
-from render_machine.render_context import RenderContext
 
-CONFORMANCE_TESTS_SUCCESS_EXIT_CODE = 0
 CONFORMANCE_TEST_MEMORY_SUBFOLDER = "conformance_test_memory"
 
 
 class MemoryManager:
+    """Manages a module's memory store at <build>/<module>/.memory.
+
+    The distilled memories are inherited by the next module in the chain (copied over when its
+    render starts, like the code repo), so learnings travel across modules.
+    """
 
     @staticmethod
     def fetch_memory_files(memory_folder: str) -> tuple[list[str], dict[str, str]]:
@@ -26,107 +28,25 @@ class MemoryManager:
     def __init__(self, codeplain_api, memory_folder: str):
         self.codeplain_api = codeplain_api
         self.memory_folder = memory_folder
+        self.journal = FixAttemptJournal(memory_folder)
 
-    def create_conformance_tests_memory(
-        self, render_context: RenderContext, exit_code: int, conformance_tests_issue: str
-    ):
-
-        current_conformance_tests_issue_frid = render_context.conformance_tests_running_context.current_testing_frid
-        current_conformance_tests_issue_module = (
-            render_context.conformance_tests_running_context.current_testing_module_name
-        )
-        old_conformance_tests_issue_frid = (
-            render_context.conformance_tests_running_context.previous_conformance_tests_issue_frid
-        )
-        old_conformance_tests_issue_module = (
-            render_context.conformance_tests_running_context.previous_conformance_tests_issue_module
-        )
-
-        old_conformance_tests_issue = (
-            render_context.conformance_tests_running_context.previous_conformance_tests_issue_old
-        )
-
-        is_first_time_running_conformance_tests = (
-            old_conformance_tests_issue_frid is None
-            or old_conformance_tests_issue_frid == ""
-            or old_conformance_tests_issue_module != current_conformance_tests_issue_module
-        )
-        is_same_frid_as_previous_failing_test = (
-            current_conformance_tests_issue_frid == old_conformance_tests_issue_frid
-            and current_conformance_tests_issue_module == old_conformance_tests_issue_module
-        )
-        is_conformance_test_failed = exit_code != CONFORMANCE_TESTS_SUCCESS_EXIT_CODE
-
-        should_create_memory = not is_first_time_running_conformance_tests and (
-            is_same_frid_as_previous_failing_test or is_conformance_test_failed
-        )
-        code_diff_files = render_context.conformance_tests_running_context.code_diff_files
+    def store_memory_files(self, response_files: dict[str, str]):
+        """Stores distilled memory files, applying deletions (None content) to existing memories."""
+        memory_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        memory_files, _ = MemoryManager.fetch_memory_files(self.memory_folder)
+        file_utils.store_response_files(memory_path, response_files, memory_files)
 
-        if not should_create_memory or code_diff_files is None:
-            console.debug(
-                "Skipping creation of conformance test memory because the conditions for creating memories are not met."
-            )
+    @staticmethod
+    def inherit_memories(source_memory_folder: str, destination_memory_folder: str):
+        """Copies the distilled memories of a previously rendered module into this module's store.
+
+        Only the distilled memories travel - fix attempt journals are transient state of one
+        module's render. A previous module without memories (e.g. shipped as an archive that
+        carries only code) is a no-op.
+        """
+        source_path = os.path.join(source_memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
+        if not os.path.isdir(source_path):
             return
-
-        existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
-            render_context.build_folder
-        )
-        memory_files, memory_files_content = MemoryManager.fetch_memory_files(self.memory_folder)
-
-        conformance_tests_folder_name = (
-            render_context.conformance_tests_running_context.get_current_conformance_test_folder_name()
-        )
-
-        (
-            _,
-            existing_conformance_test_files_content,
-        ) = render_context.conformance_tests.fetch_existing_conformance_test_files(
-            render_context.module_name,
-            render_context.required_modules,
-            render_context.conformance_tests_running_context.current_testing_module_name,
-            conformance_tests_folder_name,
-        )
-        acceptance_tests = render_context.conformance_tests_running_context.get_current_acceptance_tests()
-
-        response_files = render_context.codeplain_api.create_conformance_test_memory(
-            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(),
-            code_diff_files,
-            existing_conformance_test_files_content,
-            acceptance_tests,
-            conformance_tests_issue,
-            conformance_tests_folder_name,
-            old_conformance_tests_issue,
-            run_state=render_context.run_state,
+        file_utils.copy_folder_content(
+            source_path, os.path.join(destination_memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
         )
-        if len(response_files) > 0:
-            memory_folder_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
-            file_utils.store_response_files(memory_folder_path, response_files, memory_files)
-
-    def delete_unresolved_memory_files(self):
-        """Delete memory files whose resolution_status is not 'RESOLVED'."""
-        memory_path = os.path.join(self.memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
-        if not os.path.exists(memory_path):
-            return
-
-        memory_files = file_utils.list_all_text_files(memory_path)
-        for file_name in memory_files:
-            file_path = os.path.join(memory_path, file_name)
-            try:
-                with open(file_path, "r") as f:
-                    content = json.load(f)
-                if content.get("resolution_status") == "RESOLVED":
-                    continue
-                else:
-                    os.remove(file_path)
-            except (json.JSONDecodeError, OSError):
-                # Not a valid JSON file, unlikely to be a valid memory file, delete it
-                console.error(f"Memory file is not a valid JSON file: {file_name}. Deleting it.")
-                os.remove(file_path)
-
-            console.debug(f"Deleted temporary memory file: {file_name}")

render_machine/actions/distill_conformance_test_memory.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+from plain2code_console import console
+from render_machine.actions.base_action import BaseAction
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
+from render_machine.render_context import RenderContext
+
+
+class DistillConformanceTestMemory(BaseAction):
+    """Distills the conformance tests fix journals into durable memories once all tests pass.
+
+    Runs exactly once per functional requirement, as the first postprocessing step. When no fix
+    attempts were needed there is nothing to distill and no API call is made. Distillation is best
+    effort - a failure must never fail the render, so the journals are kept for the next
+    distillation instead.
+
+    The memories land in the module's own memory store and are inherited by the next module in the
+    chain when its render starts.
+    """
+
+    SUCCESSFUL_OUTCOME = "conformance_test_memory_distilled"
+
+    def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
+        journal = render_context.memory_manager.journal
+        fix_journals = journal.collect_all()
+        if not fix_journals:
+            return self.SUCCESSFUL_OUTCOME, None
+
+        console.info(f"Distilling conformance test fix learnings for functionality {render_context.frid_context.frid}.")
+
+        try:
+            _, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(render_context.build_folder)
+            _, memory_files_content = render_context.memory_manager.fetch_memory_files(
+                render_context.memory_manager.memory_folder
+            )
+
+            response_files = render_context.codeplain_api.distill_conformance_test_memory(
+                frid=render_context.frid_context.frid,
+                plain_source_tree=render_context.plain_source_tree,
+                linked_resources=render_context.frid_context.linked_resources,
+                existing_files_content=existing_files_content,
+                memory_files_content=memory_files_content,
+                module_name=render_context.module_name,
+                required_modules=render_context.get_required_modules_functionalities(),
+                fix_journals=fix_journals,
+                run_state=render_context.run_state,
+            )
+
+            if response_files:
+                render_context.memory_manager.store_memory_files(response_files)
+        except Exception as e:
+            console.error(f"Failed to distill conformance test memory (keeping the journals): {e}")
+            return self.SUCCESSFUL_OUTCOME, None
+
+        journal.clear_all()
+        return self.SUCCESSFUL_OUTCOME, None

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

tests/test_prepare_repositories_layout.py

@@ -18,7 +18,9 @@ from types import SimpleNamespace
 
 import pytest
 
+from conformance_fix_journal import CONFORMANCE_TEST_JOURNAL_SUBFOLDER
 from git_utils import FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE, add_all_files_and_commit, init_git_repo
+from memory_management import CONFORMANCE_TEST_MEMORY_SUBFOLDER
 from partial_rendering import archive_missing_conformance_tests, get_plain_module_render_state, get_render_choices
 from plain_modules import PlainModule
 from render_machine.actions.prepare_repositories import PrepareRepositories
@@ -115,6 +117,42 @@ def test_fresh_render_without_conformance_tests_does_not_create_tests_folder(sol
     assert not os.path.exists(solo_module.module_conformance_tests_folder)
 
 
+def test_fresh_render_inherits_memories_from_the_previous_module(root_module):
+    """The previous module's distilled memories are copied into the new module's memory store
+    (replacing any stale store), while its fix attempt journals stay behind."""
+    previous = root_module.required_modules[-1]
+    _init_repo_with_finished_frid(previous.module_build_folder, previous.module_name)
+    memory_path = Path(previous.module_memory_folder) / CONFORMANCE_TEST_MEMORY_SUBFOLDER
+    memory_path.mkdir(parents=True)
+    (memory_path / "learning.json").write_text('{"memory_id": "learning"}')
+    journal_path = Path(previous.module_memory_folder) / CONFORMANCE_TEST_JOURNAL_SUBFOLDER
+    journal_path.mkdir(parents=True)
+    (journal_path / "pr_middle__1.jsonl").write_text('{"attempt": 1}\n')
+
+    stale_memory = Path(root_module.module_memory_folder) / CONFORMANCE_TEST_MEMORY_SUBFOLDER / "stale.json"
+    stale_memory.parent.mkdir(parents=True)
+    stale_memory.write_text('{"memory_id": "stale"}')
+
+    render_context = _make_render_context(root_module, render_conformance_tests=False)
+    PrepareRepositories().execute(render_context, None)
+
+    inherited_memory_folder = Path(root_module.module_memory_folder) / CONFORMANCE_TEST_MEMORY_SUBFOLDER
+    assert sorted(os.listdir(inherited_memory_folder)) == ["learning.json"]
+    assert not stale_memory.exists()
+    assert not (Path(root_module.module_memory_folder) / CONFORMANCE_TEST_JOURNAL_SUBFOLDER).exists()
+
+
+def test_fresh_render_with_a_memoryless_previous_module_starts_with_an_empty_store(root_module):
+    previous = root_module.required_modules[-1]
+    _init_repo_with_finished_frid(previous.module_build_folder, previous.module_name)
+
+    render_context = _make_render_context(root_module, render_conformance_tests=False)
+    PrepareRepositories().execute(render_context, None)
+
+    assert os.path.isdir(os.path.join(root_module.module_build_folder, ".git"))
+    assert not os.path.exists(root_module.module_memory_folder)
+
+
 # --------------------------------------------------------------------------
 # ConformanceTests — tests-folder paths
 # --------------------------------------------------------------------------

tui/state_handlers.py

@@ -241,7 +241,13 @@ class ConformanceTestsHandler(StateHandler):
                     self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, [Substate(fixing_text)]
                 )
         else:
-            if segments[3] == States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value:
+            if segments[3] == States.CONFORMANCE_TESTS_READY_FOR_MEMORY_DISTILLATION.value:
+                update_progress_item_substates(
+                    self.tui,
+                    TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value,
+                    [Substate("Distilling conformance test fix learnings")],
+                )
+            elif segments[3] == States.CONFORMANCE_TESTS_READY_FOR_SUMMARY.value:
                 update_progress_item_substates(
                     self.tui,
                     TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value,