memstack-skill-loader 4.15.1__tar.gz → 4.16.0__tar.gz

{memstack_skill_loader-4.15.1/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.15.1
+Version: 4.16.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Project-URL: Homepage, https://memstack.pro
 Project-URL: Documentation, https://memstack.pro/docs

{memstack_skill_loader-4.15.1 → memstack_skill_loader-4.16.0}/pyproject.toml

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

{memstack_skill_loader-4.15.1 → memstack_skill_loader-4.16.0}/src/memstack_skill_loader/__init__.py

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

{memstack_skill_loader-4.15.1 → memstack_skill_loader-4.16.0}/src/memstack_skill_loader/dashboard.html

@@ -2141,7 +2141,7 @@
         <button class="mcp-tools-save-btn" style="background:#30363d;" onclick="verifyLicenseKey()">Verify</button>
         <span id="licenseKeyStatus" style="font-size:0.75rem;color:#484f58;"></span>
       </div>
-      <p style="color:#484f58;font-size:0.72rem;margin:0.35rem 0 0;">Unlocks Pro-tier compression and 42 exclusive skills. Stored at ~/.memstack/license.json.</p>
+      <p style="color:#484f58;font-size:0.72rem;margin:0.35rem 0 0;">Unlocks Pro-tier compression and <span id="settings-pro-skill-count">all</span> exclusive skills. Stored at ~/.memstack/license.json.</p>
     </div>
   </div>
 
@@ -5370,6 +5370,7 @@ async function loadSettings() {
     loadGitWorkflowGlobal();
     loadAgentModes();
     loadLicenseStatus();
+    loadProSkillCount();
     settingsLoaded = true;
   } catch (e) {
     console.error('Settings load failed:', e);
@@ -5396,6 +5397,25 @@ async function loadLicenseStatus() {
   }
 }
 
+// Pro skill count in the licence blurb, derived from /api/skills rather than
+// written into the markup -- a literal here read "42" while the enforced count
+// was 44. The static text says "all", so a failed or index-less fetch degrades
+// to a sentence that is still true rather than to a stale number.
+async function loadProSkillCount() {
+  const el = document.getElementById('settings-pro-skill-count');
+  if (!el) return;
+  try {
+    const res = await fetch('/api/skills', {headers: AUTH_GET});
+    const d = await res.json();
+    // Absent/unreadable index responses omit display_pro_count entirely and
+    // report pro_count 0; neither should overwrite the fallback.
+    const n = d.display_pro_count;
+    if (Number.isFinite(n) && n > 0) el.textContent = n;
+  } catch (e) {
+    /* keep the "all" fallback; a count is not worth a broken panel */
+  }
+}
+
 async function saveLicenseKey() {
   const input = document.getElementById('licenseKeyInput');
   const statusEl = document.getElementById('licenseKeyStatus');

memstack_skill_loader-4.16.0/src/memstack_skill_loader/diary_ingest.py

@@ -0,0 +1,467 @@
+"""Diary FACTS-block ingestion — the post-diary-save hook for the Memory Engine.
+
+The diary skill appends a ``## FACTS`` block to the markdown backup it writes to
+``memory/sessions/{date}-{project}.md``. After the save, the skill invokes this
+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, 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)
+------------------------------------------
+Ingestion must NEVER break a diary save, and it never raises: every failure is
+caught and classified. It runs AFTER the markdown is written, so the diary is
+already safe on disk before this starts.
+
+What changed from "always exits 0": the exit code now classifies the outcome,
+and every run over a diary that HAS a FACTS block prints one stdout summary
+(N ingested, M duplicate, K skipped) plus one indented reason per skipped line.
+Silence used to be the only output on success, which made a clean ingest
+indistinguishable from a hook that never ran, a wrong path, or a block that
+parsed to nothing.
+
+  exit 0  nothing was lost: no FACTS block at all (silent, nothing on stdout),
+          or at least one fact ingested, or an all-duplicates re-run of an
+          already-ingested diary (idempotency is success, not failure)
+  exit 1  content total loss: the block held at least one line, and zero facts
+          ingested AND zero duplicates. Every line was malformed or rejected.
+  exit 2  store failure: the store raised something that is NOT a
+          MemoryEngineError (IntegrityError, OperationalError), or an
+          unexpected error reached the backstop in ``main``.
+
+Two classes of failure, deliberately separated:
+
+* A BAD FACT (a malformed line, or a MemoryEngineError such as an invalid
+  subject or field) is that line's fault. It is skipped and counted, the rest of
+  the block still ingests, and on its own it does not change the exit code.
+* A BAD STORE (any other exception) is not the line's fault. The loop stops at
+  the FIRST one: if the schema rejects row 1 it will reject row 20, and
+  continuing buries the one real cause under nineteen identical warnings.
+
+Every problem still prints exactly one loud stderr line prefixed
+``memory-ingest:``. A diary with no FACTS block stays completely silent on both
+streams.
+
+Idempotency: re-running on the same entry stores nothing new. Facts are deduped
+by (source_ref, subject, claim) via ``MemoryStore.fact_exists``.
+
+REASON STRINGS NEVER ECHO THE CLAIM (do not "improve" away either)
+-----------------------------------------------------------------
+Reason strings now reach stdout, not only stderr. The claim is the free-text
+field, so it is where a pasted shell command or an API key would sit if one ever
+landed in a FACTS block, and the pipe-overflow case is the single most likely
+line to hold one. No reason string interpolates the claim. Subject and method
+tokens are echoed only via :func:`_safe_subject` / :func:`_safe_method`, which
+are ALLOWLISTS (dotted-path shape, bare word) rather than redaction patterns: a
+value that does not match is described, never printed. See the secrets policy in
+CLAUDE.md, which forbids denylist redaction for exactly this reason.
+
+FACTS block format
+------------------
+A section whose header is ``## FACTS`` / ``FACTS:`` (case-insensitive). Each
+non-blank, non-comment line until the next markdown header is one fact:
+
+    subject | claim | method [| entities]
+
+- ``subject``  dotted-path (lowercase segments joined by '.')
+- ``claim``    one assertion; must not contain '|'
+- ``method``   one of verified / reported / inferred / assumed
+- ``entities`` optional 4th field: comma-separated, optional ``entities:`` prefix
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import NamedTuple
+
+from . import memory_engine
+from .memory_engine import MemoryStore
+from .memory_db import find_project_dirs_by_name
+
+#: Prefix on every line this module emits, on either stream.
+_PREFIX = "memory-ingest:"
+#: Retained name for the stderr path (same value; kept so nothing referring to
+#: the old constant breaks).
+_STDERR_PREFIX = _PREFIX
+
+#: Longest token ever echoed into a reason string.
+_MAX_ECHO = 60
+#: Allowlist shape for an echoable method token: a bare alphabetic word.
+_SAFE_METHOD_TOKEN = re.compile(r"^[A-Za-z]{1,24}$")
+
+_FACTS_HEADER = re.compile(r"^\s*#*\s*FACTS:?\s*$", re.IGNORECASE)
+_MD_HEADER = re.compile(r"^\s*#{1,6}\s+\S")
+_COMMENT = re.compile(r"^\s*<!--.*-->\s*$")
+_ENTITIES_PREFIX = re.compile(r"^entities:\s*", re.IGNORECASE)
+_DATE_PREFIX = re.compile(r"^\d{4}-\d{2}-\d{2}-(.+)$")
+_SUFFIX_N = re.compile(r"-\d+$")
+
+
+class FactsParse(NamedTuple):
+    present: bool          # was a FACTS header found at all?
+    facts: list[dict]      # {subject, claim, method, entities}
+    errors: list[str]      # one message per malformed line, naming it
+    linenos: list[int]     # source line of each entry in `facts`, index-aligned
+
+    @property
+    def attempted(self) -> int:
+        """Non-blank, non-comment lines the block actually offered."""
+        return len(self.facts) + len(self.errors)
+
+
+def _safe_subject(field: str) -> str:
+    """Render the subject field for a reason string, or say why it is withheld.
+
+    ALLOWLIST, not a denylist. The value is echoed only when it matches the
+    dotted-path shape and fits in :data:`_MAX_ECHO`. A string of that shape
+    cannot contain a space, '=', '/', '+' or a quote, so it cannot carry a shell
+    fragment, a URL, or a base64 credential. Anything else is described.
+    """
+    value = (field or "").strip()
+    if value and len(value) <= _MAX_ECHO and memory_engine._DOTTED_PATH.match(value):
+        return f"subject '{value}'"
+    return "subject not shown (not a dotted-path)"
+
+
+def _safe_method(field: str) -> str:
+    """Render the method token for a reason string, or say why it is withheld.
+
+    Same allowlist reasoning as :func:`_safe_subject`. Echoing the token is what
+    makes a typo ('verifed') diagnosable at a glance; a bare alphabetic word
+    cannot hold a delimiter, a path, or a key.
+    """
+    value = (field or "").strip()
+    if _SAFE_METHOD_TOKEN.match(value):
+        return f"'{value}'"
+    return "(not shown: not a bare word)"
+
+
+def _parse_entities(field: str) -> list[str]:
+    field = _ENTITIES_PREFIX.sub("", field.strip())
+    return [e.strip() for e in field.split(",") if e.strip()]
+
+
+def _parse_fact_line(raw: str, lineno: int):
+    """Return (fact_dict, None) or (None, error_message).
+
+    Reason strings name the line number, what was parsed structurally (field
+    counts), and the subject/method tokens when those clear the allowlists. They
+    never interpolate the raw line or the claim: see the module docstring.
+    """
+    parts = [p.strip() for p in raw.split("|")]
+    if len(parts) < 3:
+        if len(parts) == 1:
+            # No delimiter at all, so there is no subject field to name: parts[0]
+            # here IS the whole line, which is exactly what must not be echoed.
+            return None, (
+                f"line {lineno}: expected 'subject | claim | method "
+                f"[| entities]', got 1 field (no '|' delimiter found)"
+            )
+        return None, (
+            f"line {lineno}: expected 'subject | claim | method [| entities]', "
+            f"got {len(parts)} fields; {_safe_subject(parts[0])}"
+        )
+    if len(parts) > 4:
+        return None, (
+            f"line {lineno}: too many '|'-fields ({len(parts)}, max 4); subject "
+            f"and claim must not contain '|'; {_safe_subject(parts[0])}"
+        )
+    subject, claim, method = parts[0], parts[1], parts[2]
+    entities_field = parts[3] if len(parts) == 4 else ""
+
+    if not subject or not memory_engine._DOTTED_PATH.match(subject):
+        return None, f"line {lineno}: invalid subject (expected lowercase dotted-path)"
+    if not claim:
+        return None, f"line {lineno}: empty claim; {_safe_subject(subject)}"
+    method_lc = method.lower()
+    if method_lc not in memory_engine._VALID_METHODS:
+        return None, (
+            f"line {lineno}: invalid method {_safe_method(method)} (expected one "
+            f"of verified/reported/inferred/assumed); {_safe_subject(subject)}"
+        )
+    return {
+        "subject": subject,
+        "claim": claim,
+        "method": method_lc,
+        "entities": _parse_entities(entities_field),
+    }, None
+
+
+def parse_facts_block(text: str) -> FactsParse:
+    """Parse the FACTS block out of a diary markdown document.
+
+    Never raises. If no FACTS header is present, returns ``present=False`` with
+    empty facts/errors (silent-success case). Otherwise returns the good facts
+    and one error string per malformed line.
+    """
+    lines = (text or "").splitlines()
+    start = None
+    for i, line in enumerate(lines):
+        if _FACTS_HEADER.match(line):
+            start = i + 1
+            break
+    if start is None:
+        return FactsParse(present=False, facts=[], errors=[], linenos=[])
+
+    facts: list[dict] = []
+    errors: list[str] = []
+    linenos: list[int] = []
+    for j in range(start, len(lines)):
+        raw = lines[j]
+        if _MD_HEADER.match(raw):
+            break  # next section ends the block
+        if not raw.strip() or _COMMENT.match(raw):
+            continue
+        fact, err = _parse_fact_line(raw, j + 1)
+        if err:
+            errors.append(err)
+        else:
+            facts.append(fact)
+            # Kept alongside rather than inside the fact dict: the cross-repo
+            # drift guard compares parsed fact dicts from this repo and the
+            # skill's examples for equality, and a line number in there would
+            # make that guard fail on a blank line moving in the skill.
+            linenos.append(j + 1)
+    return FactsParse(present=True, facts=facts, errors=errors, linenos=linenos)
+
+
+def _resolves(name: str) -> bool:
+    """True if the store already knows a project directory with this basename.
+
+    Any non-empty result counts. Two hits mean an ambiguous basename collision,
+    not "unknown" -- we only need to know the name exists, never which directory
+    it maps to. Fail-open: an unreachable store answers "unknown", which leaves
+    the raw slug in place rather than breaking the diary save.
+    """
+    try:
+        return bool(find_project_dirs_by_name(name))
+    except Exception:  # noqa: BLE001 -- never break the diary-save path
+        return False
+
+
+def _project_from_path(path: str) -> str:
+    """Derive a dotted-path project slug from a diary filename.
+
+    ``2026-07-20-memstack-skill-loader.md`` -> ``memstack-skill-loader``.
+
+    The diary skill writes ``{date}-{project}-N.md`` when a project already has a
+    diary for that date. Deriving the slug from the filename alone turned that
+    trailing ``-3`` into a separate project, stranding every ingested fact under
+    a phantom slug that no recall for the real project would ever reach.
+
+    So the raw name is checked against the store first, and only if it is unknown
+    do we try stripping a trailing ``-<digits>``. Checking raw first is what keeps
+    a project *genuinely* named with a trailing number (``proj-2``) resolving to
+    itself -- the suffix is only ever stripped when doing so turns an unknown name
+    into a known one. If neither resolves, the raw slug stands and downstream
+    auto-registration handles the genuinely-new project as before.
+    """
+    stem = Path(path).stem
+    m = _DATE_PREFIX.match(stem)
+    raw = m.group(1) if m else stem
+    slug = re.sub(r"[^a-z0-9_-]+", "-", raw.lower()).strip("-_") or "default"
+
+    if _resolves(slug):
+        return slug
+
+    stripped = _SUFFIX_N.sub("", slug)
+    if stripped and stripped != slug and _resolves(stripped):
+        _warn(
+            f"project {slug!r} is unknown but {stripped!r} is a known project -- "
+            f"ingesting under {stripped!r} (stripped a trailing -N diary suffix)"
+        )
+        return stripped
+
+    return slug
+
+
+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"{_PREFIX} {message}", file=sys.stderr)
+
+
+def _summary(
+    *,
+    present: bool,
+    ingested: int = 0,
+    duplicates: int = 0,
+    attempted: int = 0,
+    skipped: list[str] | None = None,
+    errors: list[str] | None = None,
+    store_failure: str | None = None,
+) -> dict:
+    """Build the result dict, deriving the exit code from what was lost.
+
+    Total loss requires zero duplicates as well as zero ingested: a re-run of an
+    already-ingested diary ingests nothing and loses nothing, so it is a success.
+    """
+    skipped = skipped or []
+    if store_failure is not None:
+        exit_code = 2
+    elif present and attempted > 0 and ingested == 0 and duplicates == 0:
+        exit_code = 1
+    else:
+        exit_code = 0
+    return {
+        "present": present,
+        "ingested": ingested,
+        "duplicates": duplicates,
+        "attempted": attempted,
+        "skipped": skipped,
+        "errors": errors if errors is not None else list(skipped),
+        "store_failure": store_failure,
+        "exit_code": exit_code,
+    }
+
+
+def _report(path: str, summary: dict) -> None:
+    """Print the one stdout summary. Callers can read this; stderr they ignore.
+
+    Only ever called for a diary that HAS a FACTS block, so a diary without one
+    stays silent on stdout as well as stderr.
+    """
+    print(
+        f"{_PREFIX} {summary['ingested']} ingested, "
+        f"{summary['duplicates']} duplicate, {len(summary['skipped'])} skipped: "
+        f"{path}"
+    )
+    for reason in summary["skipped"]:
+        print(f"  skipped {reason}")
+    if summary["store_failure"] is not None:
+        print(f"  STORE FAILURE, aborted at {summary['store_failure']}")
+    elif summary["exit_code"] == 1:
+        print(
+            f"  TOTAL LOSS: no facts ingested from {summary['attempted']} "
+            f"line(s) in the FACTS block"
+        )
+
+
+def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
+    """Parse and ingest the FACTS block from a saved diary markdown file.
+
+    Fail-open: returns a summary dict and never raises. Each problem prints one
+    stderr line, and a diary with a FACTS block also gets one stdout summary.
+    Returns ``{present, ingested, duplicates, attempted, skipped, errors,
+    store_failure, exit_code}``.
+    """
+    try:
+        text = Path(path).read_text(encoding="utf-8")
+    except OSError as exc:
+        # Unchanged: exit 0. We never got far enough to know whether this diary
+        # even had a FACTS block, so there is no loss to be loud about.
+        _warn(f"cannot read diary {path!r}: {exc}")
+        return _summary(present=False, errors=[str(exc)])
+
+    parsed = parse_facts_block(text)
+    if not parsed.present:
+        # No FACTS block: silent success (older diaries, empty sessions).
+        return _summary(present=False)
+
+    for err in parsed.errors:
+        _warn(err)
+
+    if store is None:
+        store = MemoryStore()
+    project = _project_from_path(path)
+    source_ref = _canonical_source_ref(path)
+
+    skipped: list[str] = list(parsed.errors)   # malformed lines, already warned
+    ingested = 0
+    duplicates = 0
+    store_failure: str | None = None
+
+    for fact, lineno in zip(parsed.facts, parsed.linenos):
+        try:
+            if store.fact_exists(fact["subject"], fact["claim"], source_ref):
+                duplicates += 1
+                continue
+            store.store_fact(
+                project=project,
+                subject=fact["subject"],
+                claim=fact["claim"],
+                source_type="diary",
+                source_ref=source_ref,
+                method=fact["method"],
+                entities=fact["entities"] or None,
+            )
+            ingested += 1
+        except memory_engine.MemoryEngineError as exc:
+            # The FACT is bad, not the store (invalid subject/field). Same class
+            # as a malformed line: skip it, keep going, do not fail the run.
+            # These messages name the offending field but never the claim.
+            msg = (
+                f"line {lineno}: store rejected fact "
+                f"({_safe_subject(fact['subject'])}): {exc}"
+            )
+            _warn(msg)
+            skipped.append(msg)
+        except Exception as exc:
+            # The STORE is bad (IntegrityError, OperationalError, ...). Stop at
+            # the first one: if the schema rejects this row it rejects the rest,
+            # and nineteen more identical warnings hide the one real cause.
+            store_failure = f"line {lineno}: {type(exc).__name__}: {exc}"
+            _warn(
+                f"STORE FAILURE after {ingested} ingested, aborting: "
+                f"{store_failure}"
+            )
+            break
+
+    summary = _summary(
+        present=True,
+        ingested=ingested,
+        duplicates=duplicates,
+        attempted=parsed.attempted,
+        skipped=skipped,
+        store_failure=store_failure,
+    )
+    _report(path, summary)
+    return summary
+
+
+def main(argv: list[str]) -> int:
+    """Hook entry point. Never raises; the exit code classifies the outcome.
+
+    0 = nothing lost, 1 = content total loss, 2 = store failure. See the
+    FAIL-OPEN CONTRACT in the module docstring.
+    """
+    if len(argv) < 2 or not argv[1]:
+        # A caller that passed no path lost nothing, because nothing was read.
+        _warn("no diary path provided; nothing to ingest")
+        return 0
+    try:
+        return ingest_diary_file(argv[1])["exit_code"]
+    except Exception as exc:
+        # Absolute backstop: still never raises, but this is the store or
+        # environment class of failure, so it is loud rather than silent.
+        _warn(f"unexpected error ingesting {argv[1]!r}: {exc}")
+        print(
+            f"{_PREFIX} aborted, nothing ingested: {type(exc).__name__}: {exc}"
+        )
+        return 2
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main(sys.argv))

{memstack_skill_loader-4.15.1 → memstack_skill_loader-4.16.0}/src/memstack_skill_loader/server.py

@@ -18,6 +18,7 @@ from mcp.types import TextContent, Tool
 from .config import load_config
 from .license import (
     MAX_KEY_LEN,
+    PRO_EXCLUSIVE_SKILLS,
     clear_cache,
     get_license_key,
     is_pro_exclusive,
@@ -420,9 +421,45 @@ def _record_skill_usage(skill_name: str) -> None:
     except (OSError, json.JSONDecodeError) as exc:
         print(f"[memstack] failed to record skill usage: {exc}", file=sys.stderr)
 
+
+def _free_skill_count() -> int | None:
+    """Free-skill count from the catalog that ships with the package.
+
+    skill_descriptions.json covers every canonical slug (check_skill_drift F-1
+    enforces that as a blocking check) and PRO_EXCLUSIVE_SKILLS names the Pro
+    subset, so the difference is the free count.
+
+    Deliberately NOT derived from the skill index. The messages below fire on
+    the licence-blocked path, and since 4.15.0 the startup index build is
+    fail-open, so the server can be serving with no index at all. This count
+    describes the catalog rather than the index, which keeps it correct in
+    exactly the state where an index-derived number would be unavailable.
+
+    Returns None when the catalog cannot be read or is not shaped as expected,
+    so callers can drop the number rather than print a guess.
+    """
+    try:
+        raw = (Path(__file__).parent / "skill_descriptions.json").read_text(encoding="utf-8")
+        descriptions = json.loads(raw)
+    except (OSError, ValueError):
+        return None
+    if not isinstance(descriptions, dict):
+        return None
+    free = len(descriptions) - len(PRO_EXCLUSIVE_SKILLS)
+    return free if free > 0 else None
+
+
+_FREE_SKILL_COUNT = _free_skill_count()
+# "86 free skills" when the catalog is readable, "the free skills" when it is
+# not. Never a hardcoded number: this string read "85" while the enforced
+# count was 86, in a message shown at the moment a user is asked to activate.
+_FREE_SKILLS_PHRASE = (
+    f"{_FREE_SKILL_COUNT} free skills" if _FREE_SKILL_COUNT else "the free skills"
+)
+
 _BLOCKED_MSG = (
     "MemStack\u2122 grace period expired.\n\n"
-    "Run `activate_license` with your **email** to unlock 85 free skills.\n\n"
+    f"Run `activate_license` with your **email** to unlock {_FREE_SKILLS_PHRASE}.\n\n"
     "Example: `activate_license(key=\"free\", email=\"you@example.com\")`\n\n"
     "Already have a Pro key? Run `activate_license(key=\"your-key\", email=\"you@example.com\")`."
 )
@@ -430,7 +467,7 @@ def _pro_skill_notice(skill_name: str) -> str:
     return f"{skill_name} is a Pro skill. Details at memstack.pro"
 _GRACE_EXPIRED_MSG = (
     "\U0001f512 MemStack\u2122 grace period expired. "
-    "Run `activate_license` with your email to unlock 85 free skills."
+    f"Run `activate_license` with your email to unlock {_FREE_SKILLS_PHRASE}."
 )
 _TAMPERED_MSG = (
     "\U0001f512 MemStack\u2122 Pro: License file integrity check failed. "
@@ -1802,8 +1839,12 @@ async def _handle_tool(name: str, arguments: dict) -> list[TextContent]:
             # tag reflects the just-incremented count.
             store.record_recall(h["id"], context=ctx)
             fresh = store.get_fact(h["id"])
+            # The id is what makes a recalled fact actionable: mem_inspect and
+            # mem_correct both address by id, and it is the ONLY handle that is
+            # unique by definition (nothing constrains subject to be). Rendered
+            # as '#<id>' to match mem_inspect's chain format.
             lines.append(
-                f"- **{fresh['subject']}** — {fresh['claim']} "
+                f"- #{fresh['id']} **{fresh['subject']}** — {fresh['claim']} "
                 f"{_provenance_tag(fresh)}"
             )
         return [TextContent(type="text", text="\n".join(lines))]

{memstack_skill_loader-4.15.1 → memstack_skill_loader-4.16.0/src/memstack_skill_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.15.1
+Version: 4.16.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Project-URL: Homepage, https://memstack.pro
 Project-URL: Documentation, https://memstack.pro/docs