fix(memory): keep loop rules resident and trim whole entries (#1443) (#1446)

* wip(memory): resident rules block for the loop memory index (#1443)

Work-in-progress snapshot committed by the operator after the agent's
session was interrupted by a gateway 429. Not reviewed, not test-run.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(memory): keep loop rules resident while trimming whole entries

* test(memory): expose resident index fit metrics

* chore: restore unrelated loguru regression guard

* fix(memory): report when a resident rule label stops matching

The resident block is selected by matching label text in memory/index.md --
an artifact the INSTANCE owns and can rename. A rename returns that rule to
the droppable remainder, which is precisely the failure this policy exists
to prevent, and it would happen silently: an unmatched label reads exactly
like a matched one.

last_index_fit now carries resident_matched, resident_expected and
resident_missing, and a mismatch logs a warning naming the missing labels.
Reported, never asserted -- the memory reader must not fail a cycle over
index text it does not own.

Tests pin both directions: a renamed "[DO NOT touch]" entry reports 4 of 5
with the missing label named, and an intact index reports 5 of 5 so the
counter cannot pass vacuously.

Verified against the live 8,680-byte index: 5/5 matched, kept_chars 3985,
28 entries dropped -- agreeing with the PR's accounting.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ozand

nanobot/agent/context.py

@@ -131,6 +131,7 @@ def build_system_prompt(
         sections.append(("memory", f"# Memory\n\n{memory}" if memory else ""))
         return self._fit_system_prompt(
             sections, strict=strict, degrade_on_overflow=degrade_on_overflow,
+            memory_fit=self.memory.last_index_fit,
         )
 
     SECTION_SEPARATOR = "\n\n---\n\n"
@@ -359,6 +360,7 @@ def _fit_system_prompt(
         sections: list[tuple[str, str]],
         strict: bool = False,
         degrade_on_overflow: bool = False,
+        memory_fit: dict[str, Any] | None = None,
     ) -> str:
         """Fit sections under the cap and record the outcome in :attr:`last_fit`.
 
@@ -382,6 +384,14 @@ def _fit_system_prompt(
         # max(0, non_empty_sections - 1) == chars.
         section_names = [name for name, _ in sections]
         fit: dict[str, Any] = {"cap": cap, "strict": strict, "dropped": []}
+        if memory_fit:
+            fit["memory_index"] = {
+                key: memory_fit[key]
+                for key in (
+                    "source_chars", "resident_chars", "remainder_source_chars",
+                    "remainder_kept_chars", "dropped_entries", "dropped_chars",
+                ) if key in memory_fit
+            }
         joined = self._record_fit(fit, section_names, sections)
         if len(joined) <= cap:
             occupancy = len(joined) / cap if cap else 1.0

nanobot/agent/memory.py

@@ -82,6 +82,7 @@ def __init__(self, workspace: Path):
         self.memory_file = self.memory_dir / "MEMORY.md"
         self.history_file = self.memory_dir / "HISTORY.md"
         self._consecutive_failures = 0
+        self.last_index_fit: dict[str, Any] | None = None
 
     def read_long_term(self) -> str:
         if self.memory_file.exists():
@@ -99,10 +100,87 @@ def get_memory_context(self, *, loop: bool = False, max_chars: int = 4000) -> st
         if loop:
             index = self.memory_dir / "index.md"
             text = index.read_text(encoding="utf-8") if index.is_file() else ""
-            return f"## Long-term Memory\n{text[-max_chars:]}" if text else ""
+            return self._format_loop_index(text, max_chars=max_chars) if text else ""
         long_term = self.read_long_term()
         return f"## Long-term Memory\n{long_term}" if long_term else ""
 
+    def _format_loop_index(self, text: str, *, max_chars: int) -> str:
+        """Keep policy entries resident and trim only complete index entries.
+
+        The resident block is made from the index preamble, the ``Facts``
+        heading, and the five operational entries that define identity,
+        write-target, prohibitions, rules, and host paths. The remainder is
+        selected as whole lines from newest to oldest, then restored to source
+        order. No character slice can cut a token or remove the resident block.
+
+        The labels are matched against index text the INSTANCE owns and can
+        rename. A rename would silently return that rule to the droppable
+        remainder — the failure this function exists to prevent. So the match
+        count is recorded in ``last_index_fit`` as ``resident_matched`` and
+        ``resident_missing``: a guard keyed on something that moves must at
+        least say when it stopped matching, or it reads exactly like a guard
+        that is working.
+        """
+        lines = text.splitlines(keepends=True)
+        resident_labels: tuple[str, ...] = (
+            "[Identity]", "[Write target:", "[DO NOT touch]", "[Rules]", "[Key paths",
+        )
+        matched_labels: set[str] = set()
+        resident: list[str] = []
+        remainder: list[str] = []
+        facts_heading_seen = False
+        for line in lines:
+            stripped = line.strip()
+            if not facts_heading_seen:
+                resident.append(line)
+                if stripped.startswith("## Facts"):
+                    facts_heading_seen = True
+                continue
+            hit = [label for label in resident_labels if label in line]
+            if hit:
+                matched_labels.update(hit)
+                resident.append(line)
+            else:
+                remainder.append(line)
+
+        resident_text = "".join(resident)
+        available = max(0, max_chars - len(resident_text))
+        kept_reversed: list[str] = []
+        used = 0
+        dropped = 0
+        dropped_chars = 0
+        for entry in reversed(remainder):
+            if used + len(entry) <= available:
+                kept_reversed.append(entry)
+                used += len(entry)
+            else:
+                dropped += 1
+                dropped_chars += len(entry)
+        kept = "".join(reversed(kept_reversed))
+        self.last_index_fit = {
+            "source_chars": len(text),
+            "resident_chars": len(resident_text),
+            "remainder_source_chars": len(text) - len(resident_text),
+            "remainder_kept_chars": used,
+            "kept_chars": len(resident_text) + used,
+            "dropped_entries": dropped,
+            "dropped_chars": dropped_chars,
+            "max_chars": max_chars,
+            # #1443: a resident label that stopped matching means the instance
+            # renamed that entry and the rule is droppable again. Reported, not
+            # asserted — the reader must never fail the cycle over index text.
+            "resident_matched": len(matched_labels),
+            "resident_expected": len(resident_labels),
+            "resident_missing": sorted(set(resident_labels) - matched_labels),
+        }
+        if matched_labels != set(resident_labels):
+            logger.warning(
+                "memory index: {} of {} resident rule entries matched; missing={}",
+                len(matched_labels), len(resident_labels),
+                ",".join(sorted(set(resident_labels) - matched_labels)) or "none",
+            )
+        return resident_text + kept
+
     @staticmethod
     def _format_messages(messages: list[dict]) -> str:
         lines = []

tests/test_memory_v2.py

@@ -22,16 +22,23 @@ def test_interactive_context_keeps_legacy_memory(tmp_path: Path):
     assert "FULL LEGACY BODY" in prompt
 
 
-def test_loop_memory_context_reads_tail_and_shows_freshly_added_fact(tmp_path: Path):
-    """Issue #1041 Part 1: when index.md exceeds max_chars, newest facts at the tail are visible."""
+def test_loop_memory_context_keeps_resident_rules_and_drops_whole_entries(tmp_path: Path):
+    """#1443: small caps cannot remove the rules block or split an entry."""
     from nanobot.agent.memory import MemoryStore
 
     mem_dir = tmp_path / "memory"
     mem_dir.mkdir()
     index_file = mem_dir / "index.md"
 
-    # Fill index.md with older facts totaling > 4000 chars
-    lines = [f"- [Old Fact {i}](facts/old_{i}.md) — Older context fact {i}" for i in range(100)]
+    lines = [
+        "# Memory index", "", "## Facts (memory/facts/)", "",
+        "* [Identity](facts/identity.md)",
+        "* [Write target: workspace](facts/write-target.md)",
+        "* [DO NOT touch](facts/do-not-touch.md)",
+        "* [Rules](facts/rules.md)",
+        "* [Key paths on host](facts/key-paths.md)",
+    ]
+    lines.extend(f"- [Old Fact {i}](facts/old_{i}.md) — Older context fact {i}" for i in range(100))
     lines.append("- [Brand New Fact](facts/fresh.md) — Crucial latest discovered fact")
     content = "\n".join(lines) + "\n"
     index_file.write_text(content, encoding="utf-8")
@@ -40,8 +47,90 @@ def test_loop_memory_context_reads_tail_and_shows_freshly_added_fact(tmp_path: P
     store = MemoryStore(tmp_path)
     ctx = store.get_memory_context(loop=True, max_chars=4000)
 
-    # Tail should be included, so the fresh fact is visible
+    assert "[Identity]" in ctx
+    assert "[Write target: workspace]" in ctx
+    assert "[DO NOT touch]" in ctx
+    assert "[Rules]" in ctx
+    assert "[Key paths on host]" in ctx
     assert "Crucial latest discovered fact" in ctx
     assert "Brand New Fact" in ctx
-    # Old head facts should be truncated out
     assert "Old Fact 0" not in ctx
+    assert "[trimmed" not in ctx
+    assert store.last_index_fit["dropped_entries"] > 0
+    assert store.last_index_fit["resident_chars"] <= len(ctx)
+
+
+def test_context_fit_records_memory_index_drop_details(tmp_path: Path):
+    mem_dir = tmp_path / "memory"
+    mem_dir.mkdir()
+    index = [
+        "# Memory index", "", "## Facts (memory/facts/)", "",
+        "* [Identity](facts/identity.md)", "* [Write target: workspace](facts/write-target.md)",
+        "* [DO NOT touch](facts/do-not-touch.md)", "* [Rules](facts/rules.md)",
+        "* [Key paths on host](facts/key-paths.md)",
+    ] + [f"- [Filler {i}](facts/filler_{i}.md) — {'x' * 40}" for i in range(100)]
+    (mem_dir / "index.md").write_text("\n".join(index) + "\n", encoding="utf-8")
+    builder = ContextBuilder(tmp_path)
+    builder.skills.get_always_skills = lambda: []
+    builder.skills.load_skills_for_context = lambda names: ""
+    builder.skills.build_skills_summary = lambda excluded_names=None: ""
+    prompt = builder.build_system_prompt(loop_profile=True)
+    fit = builder.last_fit
+    assert "[Identity]" in prompt and "[Rules]" in prompt
+    assert fit["memory_index"]["dropped_entries"] > 0
+    assert fit["memory_index"]["resident_chars"] > 0
+
+
+def test_renamed_rule_entry_is_reported_not_silently_droppable(tmp_path: Path):
+    """#1443: the instance owns memory/ and can rename its own facts.
+
+    The resident block is matched on index label text, so a rename returns
+    that rule to the droppable remainder -- the exact failure this policy
+    exists to prevent. That must be visible: a guard keyed on something that
+    moves reads identically to a working guard once it stops matching.
+    """
+    from nanobot.agent.memory import MemoryStore
+
+    mem_dir = tmp_path / "memory"
+    mem_dir.mkdir()
+    lines = [
+        "# Memory index", "", "## Facts (memory/facts/)", "",
+        "* [Identity](facts/identity.md)",
+        "* [Write target: workspace](facts/write-target.md)",
+        # renamed by the instance -- no longer matches "[DO NOT touch]"
+        "* [Do not modify these paths](facts/do-not-touch.md)",
+        "* [Rules](facts/rules.md)",
+        "* [Key paths on host](facts/key-paths.md)",
+    ]
+    lines.extend(f"- [Old Fact {i}](facts/old_{i}.md) — filler {i}" for i in range(100))
+    (mem_dir / "index.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    store = MemoryStore(tmp_path)
+    store.get_memory_context(loop=True, max_chars=4000)
+    fit = store.last_index_fit
+
+    assert fit["resident_matched"] == 4
+    assert fit["resident_expected"] == 5
+    assert fit["resident_missing"] == ["[DO NOT touch]"]
+
+
+def test_intact_index_reports_every_resident_label_matched(tmp_path: Path):
+    """The counter must be non-vacuous: a healthy index reports 5 of 5."""
+    from nanobot.agent.memory import MemoryStore
+
+    mem_dir = tmp_path / "memory"
+    mem_dir.mkdir()
+    lines = [
+        "# Memory index", "", "## Facts (memory/facts/)", "",
+        "* [Identity](facts/identity.md)",
+        "* [Write target: workspace](facts/write-target.md)",
+        "* [DO NOT touch](facts/do-not-touch.md)",
+        "* [Rules](facts/rules.md)",
+        "* [Key paths on host](facts/key-paths.md)",
+    ]
+    (mem_dir / "index.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    store = MemoryStore(tmp_path)
+    store.get_memory_context(loop=True, max_chars=4000)
+    assert store.last_index_fit["resident_matched"] == 5
+    assert store.last_index_fit["resident_missing"] == []