memstack-skill-loader 4.13.0__tar.gz → 4.14.0__tar.gz

{memstack_skill_loader-4.13.0/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.13.0
+Version: 4.14.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/README.md

@@ -91,6 +91,9 @@ MCP server that vector-indexes all 130 MemStack™ skills so Claude Code can cal
 - **No Anthropic API key required:** skill search and indexing run locally — the only outbound network call is license validation, which contacts the MemStack license server on session start ([Data and privacy](#data-and-privacy))
 - **Pro skills auto-detected:** set your license key and they appear automatically
 - **Auto-reindex on start:** skills stay current without manual rebuilds
+- **Memory Engine:** an append-only, versioned fact store with query-time recall scoring — facts decay with age and decay more slowly the more they are recalled. Facts flow in from the diary's `## FACTS` block and are exposed to Claude through five `mem_*` tools (see [Available Tools](#available-tools))
+- **Living memory at session start:** the SessionStart hook injects a compact, token-budgeted digest of the project's top recall-scored facts into context. It fails open — a missing, empty, or unreachable store never blocks startup
+- **8-page localhost dashboard:** Overview, Skills Manager, Burn Report, Memory Browser (project-aware diary reader), Memory Inspector (read-only Memory Engine fact views), Agent Monitor, Referrals, and Settings
 
 ### Data and privacy
 
@@ -148,6 +151,16 @@ Rebuild the vector index after adding or modifying skills.
 reindex_skills()
 ```
 
+### Memory Engine
+
+The `mem_*` tools back a persistent, append-only fact store shared across sessions (see [How It Works](#how-it-works)).
+
+- **`mem_store`** — Store a new immutable fact (subject, claim, provenance). Returns the fact id and its provenance tag.
+- **`mem_correct`** — Correct a fact by superseding it with a new one. Corrections extend only from the live tip of a chain; correcting a superseded fact is refused and names the current tip.
+- **`mem_recall`** — Recall live facts for a project, each rendered with an inline provenance tag `[method · source · recalled Nx]`. Each returned fact is logged as a recall. Optional full-text query or exact-subject filter.
+- **`mem_inspect`** — Inspect a single fact and its full supersession chain (root → tip) with statuses, provenance, entities, and recall count.
+- **`mem_stats`** — Fact-store statistics: totals by status (live/superseded/retracted), distinct subjects, and recall count. Optionally scoped to a project.
+
 ## Configuration
 
 The `config.json` file controls where skills are loaded from:

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.13.0"
+version = "4.14.0"
 description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
 requires-python = ">=3.10"
 dependencies = [

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/src/memstack_skill_loader/__init__.py

@@ -1,3 +1,3 @@
 """MemStack Skill Loader — MCP server for semantic skill search."""
 
-__version__ = "4.13.0"
+__version__ = "4.14.0"

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/src/memstack_skill_loader/dashboard.py

@@ -2127,13 +2127,19 @@ class _Handler(BaseHTTPRequestHandler):
         if route == "/api/memory-inspector/facts":
             project = qs.get("project", ["__all__"])[0]
             projects = store.list_projects()
+            # Raised from a hard-coded 500, which truncated by insertion order
+            # (list_facts is id DESC) *before* the score sort below ever ran, so
+            # the highest-scoring facts could be missing from the response
+            # entirely. _MAX_ROWS is the store's runaway guard. Pagination is
+            # deliberately still absent — tracked as separate work.
+            cap = memory_engine._MAX_ROWS
             if project and project != "__all__":
-                rows = store.list_facts(project=project, status="live", limit=500)
+                rows = store.list_facts(project=project, status="live", limit=cap)
             else:
                 rows = []
                 for p in projects:
                     rows.extend(
-                        store.list_facts(project=p["project"], status="live", limit=500)
+                        store.list_facts(project=p["project"], status="live", limit=cap)
                     )
             facts = [self._inspector_fact(f) for f in rows]
             facts.sort(key=lambda x: x["score"], reverse=True)

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/src/memstack_skill_loader/diary_ingest.py

@@ -7,7 +7,8 @@ module by path, exactly like the devlog-webhook:
     python -m memstack_skill_loader.diary_ingest "<markdown-backup-path>"
 
 Each fact line is stored through :class:`MemoryStore` with ``source_type='diary'``
-and ``source_ref`` set to the diary file path.
+and ``source_ref`` set to the diary file path, canonicalized to an absolute
+forward-slash path so the same file re-ingested from any cwd/arg form dedupes.
 
 FAIL-OPEN CONTRACT (do not "improve" away)
 ------------------------------------------
@@ -141,6 +142,25 @@ def _project_from_path(path: str) -> str:
     return slug or "default"
 
 
+def _canonical_source_ref(path: str) -> str:
+    """Canonicalize a diary path into a stable dedupe key.
+
+    The Memory Engine dedupe key is ``(source_ref, subject, claim)`` compared as
+    raw strings. A diary saved once via a relative path and once via an absolute
+    path therefore produced two different ``source_ref`` strings and re-stored
+    every fact as a duplicate live row. Resolving to a real absolute path
+    (collapsing ``..`` segments and following symlinks) and emitting it with
+    forward slashes makes every path form of the same file collapse to one key.
+
+    Fail-open: this runs in the never-break-the-diary-save path, so if resolution
+    fails for any reason, fall back to the raw string rather than raise.
+    """
+    try:
+        return Path(path).resolve().as_posix()
+    except OSError:
+        return str(path)
+
+
 def _warn(message: str) -> None:
     print(f"{_STDERR_PREFIX} {message}", file=sys.stderr)
 
@@ -169,7 +189,7 @@ def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
     if store is None:
         store = MemoryStore()
     project = _project_from_path(path)
-    source_ref = str(path)
+    source_ref = _canonical_source_ref(path)
 
     ingested = 0
     duplicates = 0

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/src/memstack_skill_loader/memory_db.py

@@ -3,6 +3,7 @@
 
 import json
 import os
+import re
 import sqlite3
 import sys
 from pathlib import Path, PureWindowsPath
@@ -10,6 +11,44 @@ from pathlib import Path, PureWindowsPath
 DB_PATH = Path.home() / ".memstack" / "memory.db"
 SCHEMA_VERSION = 1
 
+# ── project_dir canonicalization ─────────────────────────────────────────────
+# project_dir was stored raw from os.getcwd(), which on Windows returns whichever
+# drive-letter case the process happened to be launched with. Two spellings of
+# ONE directory ("C:\Projects\X" and "c:\Projects\X") therefore landed in the
+# store as distinct projects, and resolve_project_dir_by_name() — which refuses
+# to guess between multiple matches — began reporting the project as unknown.
+#
+# Storage form upper-cases the drive letter and normalizes separators, but keeps
+# the display case of the rest ("AlgoStack" must not become "algostack").
+# Comparison folds case across the whole path, because the stored paths are
+# Windows paths whether or not the reader is running on Windows — which is also
+# why PureWindowsPath is used rather than os.path (os.path.normcase is a no-op
+# on POSIX and would not fold these at all).
+#
+# Both are no-ops on anything that is not a drive-letter path, so POSIX paths
+# are never mangled.
+
+_WIN_DRIVE_RE = re.compile(r"^[A-Za-z]:[\\/]")
+
+
+def canonical_project_dir(project_dir):
+    """Storage form of a project_dir: upper-case drive, normalized separators."""
+    if not isinstance(project_dir, str) or not project_dir:
+        return project_dir
+    if not _WIN_DRIVE_RE.match(project_dir):
+        return project_dir
+    text = str(PureWindowsPath(project_dir))
+    return text[0].upper() + text[1:]
+
+
+def _project_dir_key(project_dir):
+    """Comparison key: two spellings of the same directory share a key."""
+    if not isinstance(project_dir, str) or not project_dir:
+        return ""
+    if not _WIN_DRIVE_RE.match(project_dir):
+        return project_dir
+    return str(PureWindowsPath(project_dir)).lower()
+
 
 def _resolve_db_path() -> Path:
     """Resolve the memory DB path at call time.
@@ -210,6 +249,7 @@ def insert_event(
     tokens_used: int = 0,
 ) -> int | None:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             details_json = json.dumps(details) if details is not None else None
@@ -242,6 +282,7 @@ def insert_summary(
     tokens_total: int = 0,
 ) -> int | None:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             cur = conn.execute(
@@ -286,7 +327,7 @@ def insert_lesson(
     try:
         conn = _get_conn()
         try:
-            pdir = None if global_ else project_dir
+            pdir = None if global_ else canonical_project_dir(project_dir)
             tags_json = json.dumps(stack_tags) if stack_tags else None
             if created_at:
                 # Caller-supplied timestamp: bind it (never string-format it in).
@@ -338,6 +379,7 @@ def insert_fact(
     source: str | None = None,
 ) -> int | None:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             # Delete old FTS entry if updating
@@ -386,6 +428,7 @@ def record_failed_approach(
     session_id: str | None = None,
 ) -> int | None:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             cur = conn.execute(
@@ -435,6 +478,7 @@ def query_failed_approaches(
 ) -> list[dict]:
     if top_k > 50:
         top_k = 50
+    project_dir = canonical_project_dir(project_dir)
     match = _fts_or_query(task_text)
     if not match:
         return []
@@ -472,6 +516,7 @@ def search_memory(
 ) -> list[dict]:
     if limit > 500:
         limit = 500
+    project_dir = canonical_project_dir(project_dir)
     match = _fts_or_query(query)
     if not match:
         return []
@@ -509,6 +554,7 @@ def search_memory(
 def get_recent_events(project_dir: str, limit: int = 20) -> list[dict]:
     if limit > 500:
         limit = 500
+    project_dir = canonical_project_dir(project_dir)
     try:
         conn = _get_conn()
         try:
@@ -537,6 +583,7 @@ def get_recent_events(project_dir: str, limit: int = 20) -> list[dict]:
 def get_session_summaries(project_dir: str, limit: int = 50) -> list[dict]:
     if limit > 500:
         limit = 500
+    project_dir = canonical_project_dir(project_dir)
     try:
         conn = _get_conn()
         try:
@@ -582,6 +629,7 @@ def get_lessons(
     project_dir: str | None = None, category: str | None = None
 ) -> list[dict]:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             sql = "SELECT * FROM procedural_memory WHERE 1=1"
@@ -613,6 +661,7 @@ def get_lessons(
 
 def get_facts(project_dir: str) -> list[dict]:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             rows = conn.execute(
@@ -629,6 +678,7 @@ def get_facts(project_dir: str) -> list[dict]:
 
 def get_memory_stats(project_dir: str | None = None) -> dict:
     try:
+        project_dir = canonical_project_dir(project_dir)
         conn = _get_conn()
         try:
             result: dict = {}
@@ -695,33 +745,41 @@ def get_recent_project_dirs(limit: int = 10) -> list[str]:
         return []
 
 
-def resolve_project_dir_by_name(name: str) -> str | None:
-    """Resolve a project NAME to a stored ``project_dir`` path, or None.
+def find_project_dirs_by_name(name: str) -> list[str]:
+    """Every DISTINCT directory the store knows whose basename matches ``name``.
+
+    Returns canonical paths, sorted. Spellings of the same directory collapse to
+    one entry, so the length is a count of real directories:
+
+        0  -> the store has never seen this project
+        1  -> unambiguous; ``resolve_project_dir_by_name`` returns it
+        2+ -> a genuine basename collision across different directories
+
+    ``resolve_project_dir_by_name`` cannot distinguish 0 from 2+ (both are
+    ``None``), which left callers reporting a colliding project as "unknown".
+    Callers that need to tell those apart — the diary insight bridge, which
+    auto-registers on 0 but must never guess on 2+ — use this instead.
 
     The store keeps ``project_dir`` as absolute paths (e.g.
     ``C:\\Projects\\adminstack``); callers such as the Diary only know the
     project *name* (``adminstack``). This matches ``name`` case-insensitively
     against the basename of every distinct ``project_dir`` the store already
     knows, unioned across the five tables that carry the column. It assumes no
-    on-disk layout and never fabricates a path: a name the store has never seen
-    returns None, so the function works on any machine.
+    on-disk layout and never fabricates a path, so it works on any machine.
 
     Basenames are split with ``PureWindowsPath``, not ``os.path.basename``: the
     stored paths are Windows backslash paths, and ``os.path.basename`` does not
     split on ``\\`` when this DB is read on a POSIX host. ``PureWindowsPath``
     treats both ``\\`` and ``/`` as separators regardless of the running OS.
-
-    If a basename matches more than one distinct path (a collision), returns
-    None rather than guessing which project was meant.
     """
     try:
         if name is None:
-            return None
+            return []
         if not isinstance(name, str):
             name = str(name)
         key = name.strip().lower()
         if not key:
-            return None
+            return []
 
         conn = _get_conn()
         try:
@@ -745,15 +803,39 @@ def resolve_project_dir_by_name(name: str) -> str | None:
             if PureWindowsPath(pdir).name.lower() == key:
                 matches.add(pdir)
 
-        if len(matches) == 1:
-            return next(iter(matches))
-        return None  # 0 matches => miss; >1 => ambiguous collision, do not guess
+        # Collapse spellings that denote the SAME directory (drive-letter case,
+        # separator style) before counting — otherwise one stray "c:\..." row
+        # turns a perfectly well-known project into an ambiguous one. Distinct
+        # directories that merely share a basename remain separate entries.
+        groups: dict = {}
+        for match in matches:
+            groups.setdefault(_project_dir_key(match), []).append(match)
+
+        # Deterministic representative per group: sorted() puts the upper-case
+        # drive first, and canonicalizing makes the result independent of which
+        # spellings happen to be in the store.
+        return sorted(
+            canonical_project_dir(sorted(spellings)[0])
+            for spellings in groups.values()
+        )
     except Exception as exc:
         print(
-            f"[memstack-memory] resolve_project_dir_by_name failed: {exc}",
+            f"[memstack-memory] find_project_dirs_by_name failed: {exc}",
             file=sys.stderr,
         )
-        return None
+        return []
+
+
+def resolve_project_dir_by_name(name: str) -> str | None:
+    """The single directory named ``name``, or None if unknown OR ambiguous.
+
+    Kept as the narrow, safe default for callers that only need a path and have
+    no sensible behavior for a collision. Callers that must distinguish "never
+    seen" from "shares a basename with another project" — and act differently —
+    should use :func:`find_project_dirs_by_name` and inspect the length.
+    """
+    matches = find_project_dirs_by_name(name)
+    return matches[0] if len(matches) == 1 else None
 
 
 def _human_size(nbytes: int) -> str:

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/src/memstack_skill_loader/memory_engine.py

@@ -78,7 +78,18 @@ RECENT_WINDOW = 7.0             # days: a recall this recent floors the score
 RECENT_FLOOR = 0.5              # floor applied to recently-recalled facts
 SCORE_ARCHIVE_THRESHOLD = 0.05  # below this a fact is archived out of default recall
 
+#: Hard ceiling on rows any single read returns. This is a runaway guard, NOT a
+#: ranking window: recall() orders by score *in SQL* before this applies, so the
+#: rows it trims are genuinely the lowest-scoring ones. It replaced a pair of
+#: hard-coded 500s in list_facts/search_live that silently truncated by insertion
+#: order (id DESC) before scoring ever ran — see the module tests.
+_MAX_ROWS = 10_000
+
 _TS_FMT = "%Y-%m-%d %H:%M:%S"
+#: ``now`` is bound into SQL with sub-second precision so the SQL and Python
+#: scorers evaluate at the *identical* instant (julianday parses fractional
+#: seconds). Truncating to whole seconds would let the two drift by up to ~3e-7.
+_TS_FMT_MICRO = "%Y-%m-%d %H:%M:%S.%f"
 
 
 def _parse_ts(ts: str) -> datetime:
@@ -112,6 +123,68 @@ def recall_score(fact: dict, now: datetime | None = None) -> float:
     return score
 
 
+# ---------------------------------------------------------------------------
+# SQL port of recall_score (the fast recall path)
+#
+# recall() ranks in SQL so the top-k can be chosen without materializing every
+# live fact as a Python dict. This is an EXACT port, not an approximation: the
+# only divergence is float noise between julianday's day arithmetic and
+# datetime's second arithmetic (~1e-9 on real data). `test_sql_python_score_
+# agreement` pins the two together across the whole store so they cannot drift.
+#
+# Every tunable is a BOUND PARAMETER re-read from module level on each call —
+# never interpolated into the SQL text — so the documented monkeypatch contract
+# above still holds for the SQL path.
+#
+# Parameter order (the `?`s sit in the SELECT list, so they bind before any
+# WHERE parameters):
+#   now, RECENT_WINDOW, RECENT_FLOOR,
+#   now, HALF_LIFE_BASE, HALF_LIFE_PER_RECALL,     <- floored branch
+#   now, HALF_LIFE_BASE, HALF_LIFE_PER_RECALL      <- unfloored branch
+# ---------------------------------------------------------------------------
+_SQL_SCORE = """CASE
+        WHEN f.last_recalled_at IS NOT NULL
+             AND julianday(?) - julianday(f.last_recalled_at) <= ?
+        THEN max(?, f.confidence * exp(
+                 -max(0.0, julianday(?) - julianday(f.created_at))
+                 / (? + ? * f.recall_count)))
+        ELSE f.confidence * exp(
+                 -max(0.0, julianday(?) - julianday(f.created_at))
+                 / (? + ? * f.recall_count))
+    END"""
+
+#: Probe result for SQLite's math functions, cached per process. `exp()` needs a
+#: build with SQLITE_ENABLE_MATH_FUNCTIONS (SQLite >= 3.35); `requires-python =
+#: ">=3.10"` allows stdlib builds without it. None = not yet probed. Tests force
+#: the Python path by setting this to False.
+_SQL_MATH_AVAILABLE: bool | None = None
+
+
+def _sql_score_params(now_ts: str) -> list[Any]:
+    """Bind list for :data:`_SQL_SCORE`, reading every constant at call time."""
+    return [
+        now_ts, RECENT_WINDOW, RECENT_FLOOR,
+        now_ts, HALF_LIFE_BASE, HALF_LIFE_PER_RECALL,
+        now_ts, HALF_LIFE_BASE, HALF_LIFE_PER_RECALL,
+    ]
+
+
+def _sql_math_available(conn: sqlite3.Connection) -> bool:
+    """True when this SQLite build exposes ``exp()``, cached for the process.
+
+    Correctness never depends on this probe — only speed. A build without math
+    functions falls back to the Python full scan, which returns identical rows.
+    """
+    global _SQL_MATH_AVAILABLE
+    if _SQL_MATH_AVAILABLE is None:
+        try:
+            conn.execute("SELECT exp(1.0)").fetchone()
+            _SQL_MATH_AVAILABLE = True
+        except sqlite3.Error:
+            _SQL_MATH_AVAILABLE = False
+    return _SQL_MATH_AVAILABLE
+
+
 def provenance_tag(fact: dict) -> str:
     """Inline provenance tag for a fact, e.g.
     ``[verified · diary memory/sessions/2026-07-23-demo.md · recalled 3x]``.
@@ -629,9 +702,14 @@ class MemoryStore:
         limit: int = 20,
     ) -> list[dict]:
         """List facts for a project (newest first), filtered by status
-        (default ``live``) and optionally by exact subject."""
-        if limit > 500:
-            limit = 500
+        (default ``live``) and optionally by exact subject.
+
+        Ordered by insertion (``id DESC``), so a ``limit`` below the project's
+        live count truncates by *recency of insertion*, not by relevance. Use
+        :meth:`recall` when you want the highest-scoring facts.
+        """
+        if limit > _MAX_ROWS:
+            limit = _MAX_ROWS
         conn = self._connect()
         try:
             sql = "SELECT * FROM memory_facts WHERE project=? AND status=?"
@@ -645,6 +723,22 @@ class MemoryStore:
         finally:
             conn.close()
 
+    def count_live(self, project: str) -> int:
+        """Number of live facts for ``project``.
+
+        The SessionStart block uses this to report how many live facts it did
+        NOT inject. Without it the footer could only count what fell out of the
+        candidate window, which understates the true remainder.
+        """
+        conn = self._connect()
+        try:
+            return conn.execute(
+                "SELECT COUNT(*) FROM memory_facts WHERE project=? AND status='live'",
+                (project,),
+            ).fetchone()[0]
+        finally:
+            conn.close()
+
     def list_projects(self) -> list[dict]:
         """Distinct projects that hold at least one live fact, each with its live
         count, ordered by count desc then name. Read-only; backs the dashboard
@@ -725,8 +819,8 @@ class MemoryStore:
         match = _fts_or_query(query)
         if not match:
             return []
-        if limit > 500:
-            limit = 500
+        if limit > _MAX_ROWS:
+            limit = _MAX_ROWS
         conn = self._connect()
         try:
             sql = (
@@ -745,11 +839,6 @@ class MemoryStore:
         finally:
             conn.close()
 
-    # Broad candidate cap for scored recall: we fetch up to this many live facts
-    # to rank, then return the top `limit`. Far above any realistic per-project
-    # live-fact count for a personal memory store.
-    _RECALL_CANDIDATE_CAP = 500
-
     def recall(
         self,
         project: str,
@@ -767,14 +856,87 @@ class MemoryStore:
         below ``SCORE_ARCHIVE_THRESHOLD`` are archived out of the default result
         and only surface when ``deep=True``. The archive threshold and all
         scoring constants are read from module level at call time.
+
+        Ranking happens in SQL (:data:`_SQL_SCORE`) so the whole live set is
+        ordered before ``limit`` applies. On a SQLite build without math
+        functions this falls back to scoring every candidate in Python, which
+        returns identical rows for more wall-clock. Either way the result is the
+        true top-``limit`` by score, never a slice of the most recently inserted.
         """
-        if query:
-            candidates = self.search_live(
-                query, project=project, limit=self._RECALL_CANDIDATE_CAP
+        if now is None:
+            now = datetime.now(timezone.utc)
+        if limit > _MAX_ROWS:
+            limit = _MAX_ROWS
+
+        conn = self._connect()
+        try:
+            if _sql_math_available(conn):
+                return self._recall_sql(conn, project, query, subject, deep, limit, now)
+        finally:
+            conn.close()
+        return self._recall_python(project, query, subject, deep, limit, now)
+
+    def _recall_sql(
+        self,
+        conn: sqlite3.Connection,
+        project: str,
+        query: str | None,
+        subject: str | None,
+        deep: bool,
+        limit: int,
+        now: datetime,
+    ) -> list[dict]:
+        """Score-ordered recall evaluated inside SQLite (the fast path)."""
+        now_ts = now.astimezone(timezone.utc).strftime(_TS_FMT_MICRO)
+        params: list[Any] = _sql_score_params(now_ts)
+
+        if query is not None:
+            match = _fts_or_query(query)
+            if not match:
+                return []
+            source = (
+                "memory_facts_fts fts JOIN memory_facts f ON f.id = fts.rowid "
+                "WHERE memory_facts_fts MATCH ? AND f.status='live' AND f.project=?"
             )
+            params += [match, project]
+        else:
+            source = "memory_facts f WHERE f.project=? AND f.status='live'"
+            params.append(project)
+            if subject is not None:
+                source += " AND f.subject=?"
+                params.append(subject)
+
+        # The archive threshold filters the *computed* score, so it has to sit
+        # outside the subquery that produces it.
+        outer = ""
+        if not deep:
+            outer = "WHERE score >= ? "
+            params.append(SCORE_ARCHIVE_THRESHOLD)
+        params.append(limit)
+
+        # `id DESC` tie-breaks equal scores, matching the Python path's stable
+        # sort over an id-DESC candidate list, so both paths agree exactly.
+        sql = (
+            f"SELECT * FROM (SELECT f.*, {_SQL_SCORE} AS score FROM {source}) "
+            f"{outer}ORDER BY score DESC, id DESC LIMIT ?"
+        )
+        return [dict(r) for r in conn.execute(sql, params).fetchall()]
+
+    def _recall_python(
+        self,
+        project: str,
+        query: str | None,
+        subject: str | None,
+        deep: bool,
+        limit: int,
+        now: datetime,
+    ) -> list[dict]:
+        """Score-ordered recall computed in Python (fallback; see :meth:`recall`)."""
+        if query is not None:
+            candidates = self.search_live(query, project=project, limit=_MAX_ROWS)
         else:
             candidates = self.list_facts(
-                project=project, subject=subject, limit=self._RECALL_CANDIDATE_CAP
+                project=project, subject=subject, limit=_MAX_ROWS
             )
 
         scored = []
@@ -786,7 +948,9 @@ class MemoryStore:
         if not deep:
             scored = [f for f in scored if f["score"] >= SCORE_ARCHIVE_THRESHOLD]
 
-        scored.sort(key=lambda f: f["score"], reverse=True)
+        # Explicit id tie-break so this path orders equal scores exactly as the
+        # SQL path does (which cannot rely on a stable sort).
+        scored.sort(key=lambda f: (-f["score"], -f["id"]))
         return scored[:limit]
 
     # -- internal ---------------------------------------------------------

{memstack_skill_loader-4.13.0 → memstack_skill_loader-4.14.0}/src/memstack_skill_loader/proxy/pro_compressor.py

@@ -191,7 +191,15 @@ def _truncate_python_indexed(lines: list[str]) -> list[tuple]:
                 line = lines[i]
                 recs.append(("keep", i))
             i += 1
-            # optional docstring: keep first line only
+            # Optional docstring: the summary line is always kept, and every
+            # remaining line is ACCOUNTED FOR — never dropped without a marker.
+            # Eliding the continuation lines silently made a multi-line docstring
+            # read back as a complete one-liner, so callers built edit anchors
+            # against text that does not exist on disk (function bodies never had
+            # this problem: they always leave a labelled stub behind). Interior
+            # lines therefore get the same stub treatment as a body, and the
+            # closing-quote line is kept so the docstring still reads as spanning
+            # multiple lines.
             if i < n:
                 ns = lines[i].lstrip()
                 if ns.startswith(('"""', "'''")):
@@ -199,10 +207,23 @@ def _truncate_python_indexed(lines: list[str]) -> list[tuple]:
                     q = '"""' if '"""' in ns else "'''"
                     # single-line docstring has closing quotes on same line after the open
                     if q not in ns[3:]:
-                        # multi-line: skip to closing quote
+                        # multi-line: advance to the closing quote, stubbing the
+                        # interior. Same >=2-non-blank gate as the body below — a
+                        # single interior line is kept verbatim, which is lossless
+                        # and no dearer than the labelled stub replacing it.
+                        doc_start = i + 1
                         i += 1
                         while i < n and q not in lines[i]:
                             i += 1
+                        # lines[i] is the closing-quote line, or i == n if the
+                        # docstring is unterminated (truncated/malformed input).
+                        doc_nonblank = [j for j in range(doc_start, i) if lines[j].strip()]
+                        if len(doc_nonblank) >= 2:
+                            recs.append(("stub", indent, doc_start, i - 1))
+                        elif len(doc_nonblank) == 1:
+                            recs.append(("keep", doc_nonblank[0]))
+                        if i < n:
+                            recs.append(("keep", i))
                         i += 1
                     else:
                         # single-line docstring: step past it so the body range