geny-executor 2.64.3__tar.gz → 2.64.4__tar.gz

{geny_executor-2.64.3 → geny_executor-2.64.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.64.3
+Version: 2.64.4
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.64.3 → geny_executor-2.64.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.64.3"
+version = "2.64.4"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"

{geny_executor-2.64.3 → geny_executor-2.64.4}/src/geny_executor/memory/facts.py

@@ -36,7 +36,7 @@ import json
 import logging
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Sequence, Set, Tuple
 
 from geny_executor.memory.rollup import _flatten_turn
 
@@ -238,6 +238,52 @@ _KIND_HEADINGS = {
 _IMPORTANCE_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
 
 
+IDENTITY_CARD_KINDS = ("identity", "relationship")
+_PROHIBITION_MARKERS = (
+    "금지", "금기", "언급하지", "하지 마", "하지마", "never mention", "do not ", "don't ",
+)
+
+
+def render_identity_card(facts: Sequence[Fact], *, max_chars: int = 600) -> str:
+    """Ultra-compact identity card — the facts a persona must NEVER act
+    ignorant of: who the user is, how to address them, standing
+    prohibitions. Injected by the retriever as its own never-dropped
+    layer (L1.4), independent of the pinned-notes budget, because the
+    field failure mode was exactly these facts silently falling out of
+    context and the persona asking its owner's name mid-relationship.
+
+    Returns "" when nothing qualifies (caller may fall back to
+    identity-tagged pinned notes).
+    """
+    if max_chars <= 0:
+        return ""
+    active = [f for f in facts if f.status == "active"]
+    picked: List[Fact] = [f for f in active if f.kind in IDENTITY_CARD_KINDS]
+    picked += [
+        f
+        for f in active
+        if f.kind == "preference"
+        and any(m in f.statement for m in _PROHIBITION_MARKERS)
+    ]
+    if not picked:
+        return ""
+    seen: Set[str] = set()
+    lines = ["[핀 고정 사실 — 이미 아는 것으로 전제할 것. 다시 묻지 말 것.]"]
+    used = len(lines[0])
+    for f in picked:
+        stmt = f.statement.strip()
+        key = stmt.casefold()
+        if not stmt or key in seen:
+            continue
+        seen.add(key)
+        line = f"- {stmt}"
+        if used + len(line) + 1 > max_chars:
+            break
+        lines.append(line)
+        used += len(line) + 1
+    return "\n".join(lines) if len(lines) > 1 else ""
+
+
 def render_ledger_markdown(facts: Sequence[Fact]) -> str:
     """Deterministic human-readable rendering of the ACTIVE facts, grouped
     by kind, importance-ranked inside each group. This is what the

{geny_executor-2.64.3 → geny_executor-2.64.4}/src/geny_executor/memory/provider.py

@@ -1275,6 +1275,18 @@ class MemoryHooks:
     # `NotesHandle.load_pinned(category=...)` and stamped on retrieved
     # chunks as `metadata["host_layer"]`.
     pin_category: str = "critical"
+
+    # L1.4 Identity Card (2.64.4) — its OWN small budget, never dropped and
+    # independent of the pinned layer's ratio budgeting. Rendered from the
+    # fact ledger's identity/relationship/prohibition facts (fallback:
+    # identity-tagged pinned notes). 0 disables the layer.
+    identity_card_chars: int = 600
+
+    # Categories excluded from the retriever's AUTOMATIC keyword/vector
+    # layers (explicit memory_search tool calls are unaffected). Ambient
+    # buffers like screen observations can dominate a vault (observed: 59%
+    # of 6.2k notes) and drown real recall in noise.
+    search_exclude_categories: Tuple[str, ...] = ()
     # STM tail size injected as the L0 chunk regardless of query overlap.
     recent_turns: int = 6
     # When True, MemoryAwareRetriever returns only L0/L1/L1.5/L1.7 and

{geny_executor-2.64.3 → geny_executor-2.64.4}/src/geny_executor/memory/providers/file/notes_store.py

@@ -404,13 +404,27 @@ class _FilesystemNotesStore(NotesHandle):
             modified = note.updated_at.isoformat() if note.updated_at else ""
             return (-note.importance.boost, "" if modified is None else "")  # placeholder
 
+        # Ordering (2.64.4): the fact LEDGER first — it is the designed
+        # always-inject note — then importance desc, then recency. Recency
+        # alone let a periodically-rewritten 5.6k evergreen note claim the
+        # front seat forever and crowd out identity/prohibition facts.
+        def _ledger_first(n: Note) -> int:
+            return 0 if n.ref.filename == "__facts__.md" else 1
+
         pool.sort(
             key=lambda n: (
+                _ledger_first(n),
                 -n.importance.boost,
                 -(n.updated_at.timestamp() if n.updated_at else 0.0),
             )
         )
 
+        # Per-note cap (2.64.4): one oversized note must never exhaust the
+        # whole budget. The old loop admitted the FIRST note whole even past
+        # max_chars — a 5.6k evergreen then starved every other pinned fact
+        # (and the downstream layer dropped the oversized result entirely).
+        per_note_cap = max(200, max_chars // 2)
+
         parts: List[str] = []
         used = 0
         for note in pool:
@@ -419,6 +433,8 @@ class _FilesystemNotesStore(NotesHandle):
                 continue
             header = f"## {note.title}" if note.title else ""
             piece = f"{header}\n{block}".strip() if header else block
+            if len(piece) > per_note_cap:
+                piece = piece[: per_note_cap - 12].rstrip() + "\n…(truncated)"
             cost = len(piece) + (2 if parts else 0)  # blank-line separator
             if used + cost > max_chars and parts:
                 break

{geny_executor-2.64.3 → geny_executor-2.64.4}/src/geny_executor/memory/retriever.py

@@ -154,6 +154,17 @@ class MemoryAwareRetriever(MemoryRetriever):
         )
         _record("session_summary", before)
 
+        # ── L1.4: identity card — NEVER dropped, own budget ─────────
+        # The facts a persona must never act ignorant of (owner's name,
+        # honorific, standing prohibitions). Separate from the pinned layer
+        # because pinned is ratio-budgeted and was observed starving these
+        # exact facts out of context ("asked its owner's name").
+        before = total
+        total = await self._load_identity_card(
+            chunks, total, hooks, prefetched=pf.get("identity_card", _UNFETCHED)
+        )
+        _record("identity_card", before)
+
         # ── L1.5: pinned facts (always-inject, host-policy category) ──
         before = total
         total = await self._load_pinned_facts(
@@ -276,6 +287,9 @@ class MemoryAwareRetriever(MemoryRetriever):
 
         _add("summary", _fetch_summary)
 
+        if getattr(hooks, "identity_card_chars", 0) > 0:
+            _add("identity_card", lambda: self._build_identity_card(hooks))
+
         pinned_cap = _layer_cap(hooks, "pinned")
         if pinned_cap > 0:
             _add(
@@ -285,6 +299,22 @@ class MemoryAwareRetriever(MemoryRetriever):
                 ),
             )
 
+        # Ambient-noise exclusion for the AUTOMATIC search layers (explicit
+        # memory_search tool calls are unaffected): screen-observation style
+        # buffers can dominate a vault and drown real recall.
+        _excluded = set(getattr(hooks, "search_exclude_categories", ()) or ())
+
+        def _drop_excluded(hits):
+            if not _excluded or not hits:
+                return hits
+            kept = []
+            for h in hits:
+                cat = (getattr(h, "metadata", None) or {}).get("category")
+                if cat in _excluded:
+                    continue
+                kept.append(h)
+            return kept
+
         if hooks.slim_mode or hooks.always_render_vault_map:
             _add(
                 "vault_map",
@@ -302,11 +332,16 @@ class MemoryAwareRetriever(MemoryRetriever):
                     vec = self._provider.vector()
                     if vec is None:
                         return None
-                    return await vec.search(query, top_k=hooks.max_results)
+                    return _drop_excluded(await vec.search(query, top_k=hooks.max_results))
 
                 _add("vector", _fetch_vector)
 
-            _add("kw_notes", lambda: self._provider.notes().search(query, limit=hooks.max_results))
+            async def _fetch_kw_notes() -> Any:
+                return _drop_excluded(
+                    await self._provider.notes().search(query, limit=hooks.max_results)
+                )
+
+            _add("kw_notes", _fetch_kw_notes)
             _add("kw_ltm", lambda: self._provider.ltm().search(query, limit=hooks.max_results))
 
             async def _fetch_curated() -> Any:
@@ -442,6 +477,88 @@ class MemoryAwareRetriever(MemoryRetriever):
 
     # ── L1.5 ────────────────────────────────────────────────────────
 
+    async def _load_identity_card(
+        self,
+        chunks: List[MemoryChunk],
+        total: int,
+        hooks: MemoryHooks,
+        *,
+        prefetched: Any = _UNFETCHED,
+    ) -> int:
+        cap = getattr(hooks, "identity_card_chars", 0) or 0
+        if cap <= 0:
+            return total
+        if prefetched is not _UNFETCHED:
+            text = prefetched or ""
+        else:
+            text = await self._build_identity_card(hooks)
+        if not text:
+            return total
+        # By design this layer ignores the shared budget check: it is ≤ cap
+        # (small) and the whole point is that no budget pressure can evict it.
+        chunks.append(
+            MemoryChunk(
+                key="identity_card",
+                content=text,
+                source="identity_card",
+                relevance_score=3.0,
+                metadata={"layer": "identity_card", "char_count": len(text)},
+            )
+        )
+        return total + len(text)
+
+    async def _build_identity_card(self, hooks: MemoryHooks) -> str:
+        cap = getattr(hooks, "identity_card_chars", 0) or 0
+        if cap <= 0:
+            return ""
+        # Primary: the fact ledger's identity/relationship/prohibition rows.
+        try:
+            from geny_executor.memory.facts import FactLedger, render_identity_card
+
+            state = await FactLedger(self._provider).load()
+            text = render_identity_card(state.facts, max_chars=cap)
+            if text:
+                return text
+        except Exception:  # noqa: BLE001
+            logger.debug("memory_aware: identity card (ledger) failed", exc_info=True)
+        # Fallback: identity-tagged notes in the pinned category — covers the
+        # (observed) real world where the ledger is empty but the persona has
+        # pinned "user name / honorific / taboo" notes by hand.
+        try:
+            notes = self._provider.notes()
+            metas = await notes.list(category=hooks.pin_category)
+            tags_of_interest = {"identity", "호칭", "금지주제", "금기", "이름"}
+            picked = [
+                m
+                for m in metas
+                if tags_of_interest & {str(t) for t in (m.tags or [])}
+            ]
+            if not picked:
+                return ""
+            lines = ["[핀 고정 사실 — 이미 아는 것으로 전제할 것. 다시 묻지 말 것.]"]
+            used = len(lines[0])
+            seen: set = set()
+            for m in picked:
+                note = await notes.read(m.ref.filename)
+                if note is None or not (note.body or "").strip():
+                    continue
+                stmt = " ".join((note.body or "").split())
+                key = stmt.casefold()
+                if key in seen:
+                    continue
+                seen.add(key)
+                line = f"- {stmt}"
+                if len(line) > cap // 2:
+                    line = line[: cap // 2].rstrip() + "…"
+                if used + len(line) + 1 > cap:
+                    break
+                lines.append(line)
+                used += len(line) + 1
+            return "\n".join(lines) if len(lines) > 1 else ""
+        except Exception:  # noqa: BLE001
+            logger.debug("memory_aware: identity card (fallback) failed", exc_info=True)
+            return ""
+
     async def _load_pinned_facts(
         self,
         chunks: List[MemoryChunk],
@@ -466,8 +583,19 @@ class MemoryAwareRetriever(MemoryRetriever):
         if not content or not str(content).strip():
             return total
         body = str(content)
-        if total + len(body) > budget:
+        # TRUNCATE, never drop (2.64.4). Silently discarding the whole layer
+        # when it didn't fit meant identity/prohibition facts vanished exactly
+        # on the turns with the most conversation history — the persona then
+        # asked its owner's name mid-relationship. Pinned facts are the last
+        # layer that may disappear wholesale; a bounded slice always ships.
+        room = budget - total
+        if room <= 0:
             return total
+        if len(body) > room:
+            logger.debug(
+                "memory_aware: pinned facts truncated %d → %d chars", len(body), room
+            )
+            body = body[: max(0, room - 12)].rstrip() + "\n…(truncated)"
         chunks.append(
             MemoryChunk(
                 key="pinned_facts",

geny_executor-2.64.4/tests/unit/test_identity_card_and_pinned.py

@@ -0,0 +1,159 @@
+"""Identity card + pinned-layer hardening (2.64.4).
+
+Field failure (2026-08-04, prod): a 5.6k-char always-rewritten evergreen note
+sat first in the pinned pool (recency sort), was admitted whole past the
+budget, and the retriever then DROPPED the oversized pinned layer entirely —
+the persona asked its owner's name and violated a pinned prohibition. These
+tests pin the fixes: per-note cap, ledger-first ordering, truncate-not-drop,
+and a never-dropped identity card with a notes fallback.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from geny_executor.memory.facts import Fact, FactLedger, LedgerState, render_identity_card
+from geny_executor.memory.provider import MemoryHooks, NoteDraft, Scope
+from geny_executor.memory.providers.file.provider import FileMemoryProvider
+from geny_executor.memory.retriever import MemoryAwareRetriever as GenyMemoryRetriever
+
+
+def _fact(kind: str, statement: str, fid: str = None, importance: str = "critical") -> Fact:
+    return Fact(id=fid or statement[:8], kind=kind, statement=statement, importance=importance)
+
+
+class TestRenderIdentityCard:
+    def test_identity_and_prohibition_selected(self):
+        facts = [
+            _fact("identity", "사용자 이름은 장하렴, 호칭은 '사장님' 고정", "f1"),
+            _fact("preference", "문어 이야기는 절대 언급하지 않는다 (금지)", "f2"),
+            _fact("knowledge", "드보트 140카오스 비교 기록", "f3"),
+        ]
+        card = render_identity_card(facts, max_chars=600)
+        assert "장하렴" in card and "문어" in card
+        assert "드보트" not in card, "non-identity knowledge must stay out of the card"
+        assert card.startswith("[핀 고정 사실")
+
+    def test_empty_when_nothing_qualifies(self):
+        assert render_identity_card([_fact("knowledge", "x", "k1")], max_chars=600) == ""
+        assert render_identity_card([], max_chars=600) == ""
+
+    def test_bounded_by_max_chars(self):
+        facts = [_fact("identity", "사실 " * 200, f"f{i}") for i in range(10)]
+        card = render_identity_card(facts, max_chars=300)
+        assert len(card) <= 300
+
+
+@pytest.mark.asyncio
+class TestPinnedHardening:
+    async def _seed(self, td: str) -> FileMemoryProvider:
+        p = FileMemoryProvider(root=Path(td), scope=Scope.SESSION)
+        await p.initialize()
+        # The field shape: a huge always-newest evergreen + small identity notes.
+        await p.notes().write(NoteDraft(
+            title="사용자 이름과 호칭", body="사용자 이름은 장하렴. 호칭은 사장님 고정.",
+            category="critical", filename="name.md", tags=["identity", "호칭"],
+        ))
+        await p.notes().write(NoteDraft(
+            title="금지 주제", body="문어 이야기 금지.",
+            category="critical", filename="taboo.md", tags=["금지주제"],
+        ))
+        await p.notes().write(NoteDraft(
+            title="Evergreen Memory", body="줄줄이 긴 서사 " * 400,  # ~4.8k chars, NEWEST
+            category="critical", filename="__evergreen__.md", tags=["evergreen"],
+        ))
+        return p
+
+    async def test_per_note_cap_keeps_small_facts_in(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = await self._seed(td)
+            pinned = await p.notes().load_pinned(category="critical", max_chars=2400)
+            assert len(pinned) <= 2400, "load_pinned must never return over budget"
+            assert "장하렴" in pinned, "identity note starved out by the oversized evergreen"
+            assert "문어" in pinned, "prohibition note starved out"
+
+    async def test_ledger_note_sorts_first(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = await self._seed(td)
+            state = LedgerState(facts=[_fact("identity", "레저사실: 장하렴", "L1")])
+            assert await FactLedger(p).save(state)
+            pinned = await p.notes().load_pinned(category="critical", max_chars=2400)
+            assert pinned.find("레저사실") < pinned.find("줄줄이"), "__facts__.md must lead"
+
+    async def test_retriever_truncates_pinned_instead_of_dropping(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = await self._seed(td)
+            hooks = MemoryHooks(max_inject_chars=1200, recent_turns=0, identity_card_chars=0)
+            r = GenyMemoryRetriever(p, hooks=hooks)
+            chunks, total = [], 1100  # nearly exhausted budget
+            total = await r._load_pinned_facts(chunks, total, 1200, hooks)
+            layers = [(c.metadata or {}).get("layer") for c in chunks]
+            assert "pinned" in layers, "pinned layer must be truncated, never dropped"
+            body = chunks[-1].content
+            assert len(body) <= 100 + 20  # room (100) + marker slack
+
+
+@pytest.mark.asyncio
+class TestIdentityCardLayer:
+    async def test_card_from_ledger(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = FileMemoryProvider(root=Path(td), scope=Scope.SESSION)
+            await p.initialize()
+            await FactLedger(p).save(LedgerState(facts=[
+                _fact("identity", "사용자 이름은 장하렴, 호칭 '사장님'", "f1"),
+            ]))
+            hooks = MemoryHooks(identity_card_chars=600)
+            r = GenyMemoryRetriever(p, hooks=hooks)
+            card = await r._build_identity_card(hooks)
+            assert "장하렴" in card
+
+    async def test_card_falls_back_to_tagged_notes_when_ledger_empty(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = FileMemoryProvider(root=Path(td), scope=Scope.SESSION)
+            await p.initialize()
+            await p.notes().write(NoteDraft(
+                title="사용자 이름과 호칭", body="이름 장하렴, 호칭 사장님 절대 고정.",
+                category="critical", filename="name.md", tags=["identity"],
+            ))
+            hooks = MemoryHooks(identity_card_chars=600)
+            r = GenyMemoryRetriever(p, hooks=hooks)
+            card = await r._build_identity_card(hooks)
+            assert "장하렴" in card, "empty ledger must fall back to identity-tagged notes"
+
+    async def test_card_survives_zero_budget_pressure(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = FileMemoryProvider(root=Path(td), scope=Scope.SESSION)
+            await p.initialize()
+            await FactLedger(p).save(LedgerState(facts=[
+                _fact("identity", "사용자 이름은 장하렴", "f1"),
+            ]))
+            hooks = MemoryHooks(max_inject_chars=100, identity_card_chars=600)
+            r = GenyMemoryRetriever(p, hooks=hooks)
+            chunks = []
+            await r._load_identity_card(chunks, total=10_000, hooks=hooks)
+            assert chunks and chunks[0].key == "identity_card", (
+                "identity card must inject even when the shared budget is exhausted"
+            )
+
+
+@pytest.mark.asyncio
+async def test_search_layers_exclude_configured_categories():
+    with tempfile.TemporaryDirectory() as td:
+        p = FileMemoryProvider(root=Path(td), scope=Scope.SESSION)
+        await p.initialize()
+        await p.notes().write(NoteDraft(
+            title="관측 소음", body="드보트 화면 관측 로그", category="observations", filename="obs.md",
+        ))
+        await p.notes().write(NoteDraft(
+            title="진짜 기록", body="드보트 140카오스 비교", category="topics", filename="real.md",
+        ))
+        hooks = MemoryHooks(search_exclude_categories=("observations",))
+        r = GenyMemoryRetriever(p, hooks=hooks)
+        pf = await r._prefetch_layers("드보트", hooks)
+        kw = pf.get("kw_notes") or []
+        cats = {(c.metadata or {}).get("category") for c in kw}
+        assert "observations" not in cats, "excluded category leaked into kw layer"
+        assert "topics" in cats, "legit results must survive the filter"