From a558d5e8e1322daca4e6a2c05e4d9b3c2270b617 Mon Sep 17 00:00:00 2001
From: Edgecaser <EdgeCaser@users.noreply.github.com>
Date: Wed, 25 Mar 2026 18:47:33 -0700
Subject: [PATCH] fix: use assistant prefill to prevent harvest/refresh
 returning narrative instead of memory file

The model sometimes ignores the "return only the memory file" instruction and
outputs a session summary, which the malformed-response check correctly rejects.
Adding an assistant prefill that starts with the first line of the current memory
file forces the model to continue in the expected format.

Also prints the raw malformed response on failure for easier debugging.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 memsync/cli.py        |  4 +++-
 memsync/sync.py       | 53 ++++++++++++++++++++++++++++++++++++-------
 tests/test_harvest.py | 14 +++++++++++-
 tests/test_sync.py    | 14 +++++++++++-
 4 files changed, 74 insertions(+), 11 deletions(-)

diff --git a/memsync/cli.py b/memsync/cli.py
index 1956f96..65acda5 100644
--- a/memsync/cli.py
+++ b/memsync/cli.py
@@ -577,9 +577,11 @@ def cmd_harvest(args: argparse.Namespace, config: Config) -> int:
     if result.get("malformed"):
         print(
             "\nError: API response does not look like a memory file (missing leading # or <!--).\n"
-            "Memory file was NOT updated.",
+            "Memory file was NOT updated. The raw response has been printed below for"
+            " inspection.\n",
             file=sys.stderr,
         )
+        print(result["updated_content"], file=sys.stderr)
         return 6
 
     # Mark session as harvested with current message count
diff --git a/memsync/sync.py b/memsync/sync.py
index f1dcaef..78d5d9e 100644
--- a/memsync/sync.py
+++ b/memsync/sync.py
@@ -65,14 +65,18 @@ def harvest_memory_content(transcript: str, current_memory: str, config: Config)
 SESSION TRANSCRIPT:
 {transcript}"""
 
+    prefill = _build_prefill(current_memory)
     response = client.messages.create(
         model=config.model,
         max_tokens=4096,
         system=HARVEST_SYSTEM_PROMPT,
-        messages=[{"role": "user", "content": user_prompt}],
+        messages=[
+            {"role": "user", "content": user_prompt},
+            {"role": "assistant", "content": prefill},
+        ],
     )
 
-    updated_content = _strip_code_fences(response.content[0].text)
+    updated_content = _strip_model_wrapper(prefill + response.content[0].text)
 
     if not _looks_like_memory_file(updated_content):
         return {
@@ -98,12 +102,29 @@ def harvest_memory_content(transcript: str, current_memory: str, config: Config)
     }
 
 
-def _strip_code_fences(content: str) -> str:
+def _build_prefill(current_memory: str) -> str:
     """
-    Strip leading/trailing code fences the model sometimes wraps responses in.
-    Handles ```markdown, ```md, or plain ``` openings.
+    Build an assistant prefill string that forces the model to start outputting
+    the memory file rather than a narrative summary.
+
+    Uses the first line of the current memory if it looks like a valid start
+    (heading or comment marker), otherwise falls back to the memsync comment.
+    """
+    first_line = current_memory.strip().splitlines()[0] if current_memory.strip() else ""
+    if first_line.startswith("#") or first_line.startswith("<!--"):
+        return first_line
+    return "<!-- memsync v0.2 -->"
+
+
+def _strip_model_wrapper(content: str) -> str:
+    """
+    Strip wrapper artifacts the model sometimes adds around the memory file:
+    - Code fences (```markdown, ```md, plain ```)
+    - Preamble lines before the first heading ("Here's the updated...", etc.)
     """
     stripped = content.strip()
+
+    # Strip code fences first
     if stripped.startswith("```"):
         lines = stripped.splitlines()
         # Remove opening fence line (e.g. ```markdown)
@@ -111,7 +132,19 @@ def _strip_code_fences(content: str) -> str:
         # Remove closing fence if present
         if lines and lines[-1].strip() == "```":
             lines = lines[:-1]
-        return "\n".join(lines).strip()
+        stripped = "\n".join(lines).strip()
+
+    # Strip preamble lines before the first heading or comment marker.
+    # The model sometimes leads with "Here's the updated memory file:" or similar.
+    lines = stripped.splitlines()
+    while lines:
+        first = lines[0].strip()
+        if first.startswith("#") or first.startswith("<!--") or first == "":
+            break
+        # This line is preamble — drop it
+        lines = lines[1:]
+    stripped = "\n".join(lines).strip()
+
     return stripped
 
 
@@ -139,14 +172,18 @@ def refresh_memory_content(notes: str, current_memory: str, config: Config) -> d
 SESSION NOTES:
 {notes}"""
 
+    prefill = _build_prefill(current_memory)
     response = client.messages.create(
         model=config.model,
         max_tokens=4096,
         system=SYSTEM_PROMPT,
-        messages=[{"role": "user", "content": user_prompt}],
+        messages=[
+            {"role": "user", "content": user_prompt},
+            {"role": "assistant", "content": prefill},
+        ],
     )
 
-    updated_content = _strip_code_fences(response.content[0].text)
+    updated_content = _strip_model_wrapper(prefill + response.content[0].text)
 
     # Reject responses that look like narrative explanations rather than a memory file.
     # The model occasionally ignores "no preamble" and returns prose — writing that
diff --git a/tests/test_harvest.py b/tests/test_harvest.py
index e1d345d..10fb2ba 100644
--- a/tests/test_harvest.py
+++ b/tests/test_harvest.py
@@ -308,7 +308,19 @@ def test_ignores_invalid_dict_entries(self, tmp_path):
 # ---------------------------------------------------------------------------
 
 class TestHarvestMemoryContent:
-    def _make_mock_response(self, text: str, stop_reason: str = "end_turn") -> MagicMock:
+    def _make_mock_response(self, text: str, stop_reason: str = "end_turn",
+                            current_memory: str = SAMPLE_MEMORY) -> MagicMock:
+        """
+        Simulate the API returning a continuation after the prefill.
+
+        With assistant prefill, the API only returns the text *after* the prefill.
+        The code then combines: prefill + response.content[0].text.
+        So the mock must strip the prefill line from the expected output.
+        """
+        from memsync.sync import _build_prefill
+        prefill = _build_prefill(current_memory)
+        if text.startswith(prefill):
+            text = text[len(prefill):]
         mock = MagicMock()
         mock.content = [MagicMock(text=text)]
         mock.stop_reason = stop_reason
diff --git a/tests/test_sync.py b/tests/test_sync.py
index bf3bfd7..6b9326b 100644
--- a/tests/test_sync.py
+++ b/tests/test_sync.py
@@ -136,7 +136,19 @@ def test_content_includes_notes(self, tmp_path):
 
 
 class TestRefreshMemoryContent:
-    def _make_mock_response(self, text: str, stop_reason: str = "end_turn") -> MagicMock:
+    def _make_mock_response(self, text: str, stop_reason: str = "end_turn",
+                            current_memory: str = SAMPLE_MEMORY) -> MagicMock:
+        """
+        Simulate the API returning a continuation after the prefill.
+
+        With assistant prefill, the API only returns the text *after* the prefill.
+        The code then combines: prefill + response.content[0].text.
+        So the mock must strip the prefill line from the expected output.
+        """
+        from memsync.sync import _build_prefill
+        prefill = _build_prefill(current_memory)
+        if text.startswith(prefill):
+            text = text[len(prefill):]
         mock_response = MagicMock()
         mock_response.content = [MagicMock(text=text)]
         mock_response.stop_reason = stop_reason