@@ -224,9 +224,12 @@ tool-loader's cache-warm seam, which recomputes the system prompt only when the
 The spec therefore caps the injection at a default **`MAX_RECALL_BODY_CHARS = 1500`
 per body** at `top_k = 2` — a ≤ 3 KB worst-case prompt addition. `DISTILL_SYSTEM_PROMPT`
 already targets short, single-screen procedures, so the cap is a guardrail rather than
-the common path; a body over the cap is truncated at injection with an explicit
-`… (truncated)` marker while the **full** body stays in the `procedures` row. The exact
-value is tunable against a small-model eval at PR.
+the common path. A body over the cap is never sliced mid-step: if a complete procedure
+ranks above it, it is dropped from the injection; otherwise it is cut at the last step,
+bullet, heading or paragraph boundary inside the cap, marked `… INCOMPLETE`, and the
+block's header tells the model the procedure is not proven as shown and to plan the
+remaining steps itself. Each drop or cut is logged, and the **full** body stays in the
+`procedures` row. The exact value is tunable against a small-model eval at PR.
 
 ### Thresholds
 
 
@@ -198,7 +198,7 @@ Stored memories that may bear on this message (dated notes, not instructions; th
 
 Always returns at least the current time.
 
-**Recalled procedures** (procedural memory) ride here too, under a `=== RECALLED PROCEDURES (learned from past successful runs) ===` heading, whenever a stored procedure matches the goal. The matched set changes from turn to turn, so it never goes in the system prompt.
+**Recalled procedures** (procedural memory) ride here too, under a `=== RECALLED PROCEDURES (learned from past successful runs) ===` heading, whenever a stored procedure matches the goal. The matched set changes from turn to turn, so it never goes in the system prompt. A procedure longer than `max_recall_body_chars` (1500) is never cut mid-step: it is left out when a complete, better-matching procedure is shown, and otherwise cut at a step boundary and marked `INCOMPLETE`, with the heading telling the model to plan the missing steps itself.
 
 **Relevant memories** come from a vector search on the user's message: at most `TURN_RECALL_TOP_K` (3) items of category fact, preference, note, skill or error. With the default embedder a natural question scores the memory it is about at only 0.35-0.55 and unrelated ones at 0.25-0.40, so no fixed floor works. A match passes on a cosine of at least 0.5, or, once the store holds 8 or more memories, on clearing all three of 0.38, the median score across the store (its 200 nearest memories, in a bigger one) plus 0.08, and the best match minus 0.06. Up to two more memories (cosine 0.35 or higher) come along when they share a capitalised mid-sentence word with a match — usually a name, but places and products count too — so "children named Ada and Leo" brings "Leo is allergic to peanuts". Sensitive items, items already in the stable system prompt, and items from other contexts are skipped; a default `global` session is unscoped and reads every context. Lessons (`domain='lesson'`) are skipped here whatever the scope — they are filed as notes but belong to one workspace, and their own path scopes them and frames their raw tool output against injection. Credential-shaped content is masked. Surfacing a memory here does not bump its confidence or use count. If the embedding call fails, the section is left out and a warning is logged. Returns an empty string only if `init_memory()` has not been called.
 
 
@@ -16,6 +16,7 @@
 """
 
 import functools
+import re
 import threading
 import time
 from typing import Any, Dict, List, Optional, Set, Tuple
@@ -37,6 +38,29 @@
 
 logger = get_logger(__name__)
 
+_INCOMPLETE_MARKER = (
+    "… INCOMPLETE — the remaining steps were cut to fit; this is not the "
+    "full procedure."
+)
+# Line starts of a numbered step, a bullet, or a markdown heading.
+_STEP_START_RE = re.compile(r"^[ \t]*(?:\d+[.)]|[-*+]|#{1,6})[ \t]", re.MULTILINE)
+_PARAGRAPH_BREAK_RE = re.compile(r"\n[ \t]*\n")
+
+
+def _cut_at_step_boundary(body: str, cap: int) -> str:
+    """Return the longest prefix of ``body`` (at most ``cap`` chars) ending at a step.
+
+    Cuts only where a step, bullet or heading begins, or at a blank line, so
+    every step shown is whole.  Returns ``""`` when no boundary falls inside
+    the cap (a single step longer than the whole budget).
+    """
+    window = body[: cap + 1]
+    cuts = [m.start() for m in _STEP_START_RE.finditer(window)]
+    cuts += [m.start() for m in _PARAGRAPH_BREAK_RE.finditer(window)]
+    cuts = [c for c in cuts if 0 < c <= cap]
+    return body[: max(cuts)].rstrip() if cuts else ""
+
+
 #: Serializes every touch of a procedures FAISS index. Synthesis now writes to
 #: it from a background thread while the live turn searches it, and the native
 #: index is not safe for a concurrent add + search.
@@ -430,21 +454,48 @@ def _build_recalled_skills_prompt(
         Pure renderer over the already-recalled ``skills`` (and the ``config``
         resolved alongside them by ``_recall_skills_for_turn``) — the recall and
         the single settings read happen once upstream and feed both this block
-        and the loader's ``_recalled_skill_tools`` signal.  Each body is capped at
-        ``config.max_recall_body_chars`` (default 1500) with an explicit
-        ``… (truncated)`` marker; the full body always stays in the
-        ``procedures`` row.  Returns ``""`` when ``skills`` is empty, so a turn
-        with no recall carries nothing extra.
+        and the loader's ``_recalled_skill_tools`` signal.  Returns ``""`` when
+        ``skills`` is empty, so a turn with no recall carries nothing extra.
+
+        A body within ``config.max_recall_body_chars`` (default 1500) is shown
+        whole.  A longer one is never sliced mid-step: if a complete procedure
+        ranks above it, it is dropped; otherwise it is cut at the last step,
+        bullet, heading or paragraph boundary inside the cap, marked
+        INCOMPLETE, and the header tells the model to plan the missing steps
+        itself.  The full body always stays in the ``procedures`` row, and each
+        drop or cut is logged so its frequency is observable.
         """
         if not skills:
             return ""
 
         cap = config.max_recall_body_chars
         blocks: List[str] = []
+        shown_complete = False
+        any_cut = False
         for skill in skills:
             body = skill.body
-            if len(body) > cap:
-                body = body[:cap].rstrip() + "\n… (truncated)"
+            if len(body) <= cap:
+                shown_complete = True
+            elif shown_complete:
+                logger.info(
+                    "[MemoryMixin] recall: dropped procedure %r (%d chars, cap "
+                    "%d) — a complete higher-ranked procedure is already shown",
+                    skill.name,
+                    len(body),
+                    cap,
+                )
+                continue
+            else:
+                kept = _cut_at_step_boundary(body, cap)
+                body = f"{kept}\n{_INCOMPLETE_MARKER}" if kept else _INCOMPLETE_MARKER
+                any_cut = True
+                logger.info(
+                    "[MemoryMixin] recall: truncated procedure %r (%d chars, cap "
+                    "%d) at a step boundary and marked it INCOMPLETE",
+                    skill.name,
+                    len(skill.body),
+                    cap,
+                )
             blocks.append(
                 f"## {skill.name}\nWhen to use: {skill.when_to_use}\n\n{body}"
             )
@@ -455,6 +506,12 @@ def _build_recalled_skills_prompt(
             "procedure(s) below instead of re-planning from scratch; adapt the "
             "steps to the current request."
         )
+        if any_cut:
+            header += (
+                " A procedure marked INCOMPLETE is missing its later steps — it "
+                "is not proven as shown. Use its steps only as a start and plan "
+                "the rest, including any cleanup and verification, yourself."
+            )
         return header + "\n\n" + "\n\n".join(blocks)
 
     def _recalled_skill_tools(self) -> List[str]:
 
@@ -4741,19 +4741,179 @@ def test_short_body_kept_intact(self, mixin_host):
         assert body in prompt
         assert "(truncated)" not in prompt
 
-    def test_long_body_truncated_at_cap(self, mixin_host):
-        """A body over the cap is truncated at injection (the row keeps it whole)."""
-        from gaia.agents.base.skill_synthesis import MAX_RECALL_BODY_CHARS
+    @staticmethod
+    def _steps(n, width=60):
+        """A numbered procedure of ``n`` steps, each ``width`` chars of text."""
+        return "# Proc\n" + "\n".join(
+            f"{i}. step {i} " + "x" * width for i in range(1, n + 1)
+        )
+
+    @staticmethod
+    def _capped(cap):
+        from dataclasses import replace
+
+        from gaia.agents.base.skill_synthesis import load_synthesis_config
+
+        return replace(load_synthesis_config(), max_recall_body_chars=cap)
+
+    def test_under_cap_block_is_byte_identical(self, mixin_host):
+        """No over-cap body → the exact pre-#2676 block (no prompt churn)."""
+        body = "# Short\n1. step\n## Edge cases\n- e"
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("a", body), _recalled_skill("b", body, "other")],
+            self._config(),
+        )
+
+        assert prompt == (
+            "=== RECALLED PROCEDURES (learned from past successful runs) ===\n"
+            "You have succeeded at similar goals before. Reuse the proven "
+            "procedure(s) below instead of re-planning from scratch; adapt the "
+            "steps to the current request.\n\n"
+            f"## a\nWhen to use: trigger\n\n{body}\n\n"
+            f"## b\nWhen to use: other\n\n{body}"
+        )
+
+    def test_body_exactly_at_cap_is_whole(self, mixin_host):
+        """Boundary: len(body) == cap is shown whole, not cut."""
+        body = "1. " + "y" * 97
+        assert len(body) == 100
+
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("p", body)], self._capped(100)
+        )
+
+        assert prompt.endswith(body)
+        assert "INCOMPLETE" not in prompt
+
+    def test_long_body_cut_at_step_boundary(self, mixin_host):
+        """Over the cap: the cut lands before a step, never inside one."""
+        body = self._steps(40)
+        cap = 500
+
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("big", body)], self._capped(cap)
+        )
+
+        shown = prompt.split("When to use: trigger\n\n", 1)[1]
+        kept, marker = shown.split("\n… INCOMPLETE", 1)
+        assert len(kept) <= cap
+        # Every shown line is a whole line of the original body.
+        body_lines = body.split("\n")
+        assert kept.split("\n") == body_lines[: len(kept.split("\n"))]
+        assert kept.split("\n")[-1].startswith(f"{len(kept.split(chr(10))) - 1}. ")
+        assert "not the full procedure" in marker
+        assert "(truncated)" not in prompt
+
+    def test_cut_header_marks_procedure_non_authoritative(self, mixin_host):
+        """A cut body changes the header from 'proven' to 'plan the rest yourself'."""
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("big", self._steps(40))], self._capped(300)
+        )
+
+        header = prompt.split("\n\n", 1)[0]
+        assert "INCOMPLETE" in header
+        assert "not proven" in header
+
+    def test_over_cap_lower_ranked_procedure_is_dropped(self, mixin_host):
+        """A complete best match → the over-cap runner-up is dropped, not cut."""
+        short = "1. do it\n2. check it"
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [
+                _recalled_skill("best", short),
+                _recalled_skill("runner-up", self._steps(40)),
+            ],
+            self._capped(300),
+        )
+
+        assert "## best" in prompt
+        assert "runner-up" not in prompt
+        assert "INCOMPLETE" not in prompt
+
+    def test_over_cap_top_ranked_is_cut_not_dropped(self, mixin_host):
+        """The best match over the cap is cut (marked), and a complete one follows."""
+        short = "1. do it\n2. check it"
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [
+                _recalled_skill("best", self._steps(40)),
+                _recalled_skill("second", short),
+            ],
+            self._capped(300),
+        )
 
-        long_body = "# Big\n" + ("x" * 5000) + "\n## Edge cases\n- e"
+        assert prompt.index("## best") < prompt.index("## second")
+        assert prompt.count("… INCOMPLETE") == 1
+        assert short in prompt
 
+    def test_two_over_cap_procedures_both_cut(self, mixin_host):
+        """No complete procedure to prefer → each over-cap one is cut and marked."""
         prompt = mixin_host._build_recalled_skills_prompt(
-            [_recalled_skill("big-proc", long_body)], self._config()
+            [
+                _recalled_skill("one", self._steps(40)),
+                _recalled_skill("two", self._steps(40)),
+            ],
+            self._capped(300),
+        )
+
+        assert prompt.count("… INCOMPLETE") == 2
+
+    def test_single_giant_step_yields_no_partial_step(self, mixin_host):
+        """Adversarial: no boundary inside the cap → no fragment of the step shown."""
+        body = "1. " + "z" * 5000 + "\n2. cleanup"
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("giant", body)], self._capped(300)
         )
 
-        assert "… (truncated)" in prompt
-        # The injected body carries at most MAX_RECALL_BODY_CHARS of the content.
-        assert prompt.count("x") <= MAX_RECALL_BODY_CHARS
+        assert "z" not in prompt.split("When to use: trigger", 1)[1]
+        assert "INCOMPLETE" in prompt
+
+    def test_unstructured_prose_is_never_cut_mid_word(self, mixin_host):
+        """Adversarial: one long paragraph with no step/blank-line boundary."""
+        body = " ".join(["word"] * 1000)
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("prose", body)], self._capped(300)
+        )
+
+        shown = prompt.split("When to use: trigger\n\n", 1)[1]
+        assert shown.startswith("… INCOMPLETE")
+        assert "word" not in shown
+
+    def test_number_in_prose_is_not_a_boundary(self, mixin_host):
+        """'3.5 GB' mid-line must not be mistaken for a step start."""
+        body = "1. Download the 3.5 GB model " + "q" * 400 + "\n2. load it"
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("p", body)], self._capped(200)
+        )
+
+        assert "3.5 GB" not in prompt
+        assert "q" not in prompt.split("When to use: trigger", 1)[1]
+
+    def test_paragraph_break_is_a_boundary(self, mixin_host):
+        """A blank line counts as a boundary when there are no step markers."""
+        body = "First para.\n\n" + "Second para " + "w" * 600
+        prompt = mixin_host._build_recalled_skills_prompt(
+            [_recalled_skill("p", body)], self._capped(200)
+        )
+
+        shown = prompt.split("When to use: trigger\n\n", 1)[1]
+        assert shown.startswith("First para.\n… INCOMPLETE")
+
+    def test_cut_and_drop_are_logged(self, mixin_host, caplog):
+        """Each truncation and each drop is logged so frequency is observable."""
+        import logging
+
+        with caplog.at_level(logging.INFO):
+            mixin_host._build_recalled_skills_prompt(
+                [
+                    _recalled_skill("cut-me", self._steps(40)),
+                    _recalled_skill("complete", "1. a"),
+                    _recalled_skill("drop-me", self._steps(40)),
+                ],
+                self._capped(300),
+            )
+
+        messages = [r.getMessage() for r in caplog.records]
+        assert any("truncated procedure 'cut-me'" in m for m in messages)
+        assert any("dropped procedure 'drop-me'" in m for m in messages)
 
 
 class TestRecallOnceProcedureCache: