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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.10.dev3
+Version: 0.3.10.dev5
 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.dev5.dist-info}/RECORD

@@ -1,16 +1,17 @@
 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
 path_resolution.py,sha256=0tMqU0a1g4DYhTOp7QjLVSEkv_cgasb4NI1mK809dUM,2233
-plain2code.py,sha256=NsZf7JS2bGmOQ6HsbiTqNA3EMXXY5YQW6nBBXCG7m-U,17392
+plain2code.py,sha256=v8xBTv3mQjntpBTBJUvl5naGnSPFAzhEQTqpeRr40ow,18072
 plain2code_arguments.py,sha256=xMK-R13Vu005bHz3MUDY8F0Cf3ED9hCPqNsC6jGZmkk,17620
 plain2code_console.py,sha256=5N4_GIV8qE-2zvFh6qoOHhhsuwCF_3r7jG19S-YWtfk,5906
 plain2code_events.py,sha256=rgDF5PDtNr_lEPvJmd1tIQXZrzwgzZW5b-_pykugqe4,1587
@@ -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,10 @@ 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_dry_run_link_validation.py,sha256=ivvYXQPqUkQ8glbFyUrdCninCxF2mg-rAsDcfjcB7MM,2140
 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 +92,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 +109,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.dev5.dist-info/METADATA,sha256=nG1mz4SKQy9tZ2ybsG-Va9_plwrluGfGVc9AxONWh2s,7256
+codeplain-0.3.10.dev5.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+codeplain-0.3.10.dev5.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
+codeplain-0.3.10.dev5.dist-info/licenses/LICENSE,sha256=pCeKgQ1mXE5OmNUuKOfOZh1T1vqkeCUxghE7N8qgnzc,11345
+codeplain-0.3.10.dev5.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}")

plain2code.py

@@ -203,6 +203,15 @@ def warn_if_acceptance_tests_without_conformance_script(plain_module, args) -> N
     )
 
 
+def validate_linked_resources(plain_module) -> None:
+    """Load every linked resource exactly the way rendering does, so dry-run
+    surfaces the same errors (binary file, missing file, oversized base64 blob)."""
+    for module in plain_module.all_required_modules + [plain_module]:
+        resources_list: list[dict] = []
+        plain_spec.collect_linked_resources(module.plain_source, resources_list, None, True)
+        file_utils.load_linked_resources(module.template_dirs, resources_list, module.module_name)
+
+
 def render(  # noqa: C901
     plain_module: plain_modules.PlainModule,
     args,
@@ -393,6 +402,12 @@ def main():  # noqa: C901
         return
 
     if args.dry_run:
+        try:
+            validate_linked_resources(plain_module)
+        except Exception as e:
+            console.error(f"Error: {str(e)}")
+            return
+
         console.info("Printing dry run output...\n")
         render_range = plain_spec.compute_render_range(args, plain_module.plain_source)
         print_dry_run_output(plain_module.plain_source, render_range)

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