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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.16.0
+Version: 4.18.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.16.0 → memstack_skill_loader-4.18.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.16.0"
+version = "4.18.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.16.0 → memstack_skill_loader-4.18.0}/src/memstack_skill_loader/__init__.py

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

{memstack_skill_loader-4.16.0 → memstack_skill_loader-4.18.0}/src/memstack_skill_loader/__main__.py

@@ -161,6 +161,12 @@ def main():
     elif len(sys.argv) > 2 and sys.argv[1] == "run":
         task = " ".join(sys.argv[2:])
         _run_agents(task)
+    elif len(sys.argv) > 1 and sys.argv[1] == "memory-migrate":
+        # Data migrations over the Memory Engine fact store. Dispatched here and
+        # nowhere else: no import-time hook, no call from MemoryStore, so a
+        # migration can only run because someone typed it.
+        from .memory_migrations import main as migrate_main
+        sys.exit(migrate_main(sys.argv[2:]))
     elif len(sys.argv) > 1 and sys.argv[1] == "proxy":
         import argparse
         parser = argparse.ArgumentParser(prog="memstack proxy")

{memstack_skill_loader-4.16.0 → memstack_skill_loader-4.18.0}/src/memstack_skill_loader/diary_ingest.py

@@ -6,6 +6,10 @@ module by path, exactly like the devlog-webhook:
 
     python -m memstack_skill_loader.diary_ingest "<markdown-backup-path>"
 
+Pass ``--project NAME`` to override the derived project entirely. That is the
+escape hatch for a project whose real name looks like another project's name
+plus a suffix, which the derivation's third rung would otherwise shorten.
+
 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.
@@ -18,10 +22,16 @@ 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.
+(N ingested, M duplicate, K skipped into project 'X') 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.
+
+The summary NAMES THE PROJECT it wrote to, and marks a namespace nothing has
+ever been stored under as NEW. Counting alone was not enough: a diary misfiled
+under a phantom namespace still reported a perfectly clean "17 ingested" and
+exited 0, so the number a reader would check was right while the facts were
+unreachable from any recall for the real project.
 
   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
@@ -230,54 +240,122 @@ def parse_facts_block(text: str) -> FactsParse:
     return FactsParse(present=True, facts=facts, errors=errors, linenos=linenos)
 
 
-def _resolves(name: str) -> bool:
+def _resolves(name: str, failures: list[str] | None = None) -> 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.
+
+    Failing open is still right, but it used to be SILENT, and a silent
+    "unknown" is indistinguishable from a real one: an unreachable store minted
+    a phantom namespace for every project on the machine and said nothing. So
+    the first failure of a derivation warns, naming only the exception CLASS.
+    The exception's message is never echoed -- it is attacker-influenced free
+    text in the same sense a claim is, and the secrets policy forbids printing
+    what has not cleared an allowlist.
+
+    ``failures`` collects the classes seen so one derivation warns once rather
+    than once per rung; passing None keeps the single-shot behavior for direct
+    callers.
     """
     try:
         return bool(find_project_dirs_by_name(name))
-    except Exception:  # noqa: BLE001 -- never break the diary-save path
+    except Exception as exc:  # noqa: BLE001 -- never break the diary-save path
+        if not failures:
+            _warn(
+                f"project lookup failed ({type(exc).__name__}); cannot tell a "
+                f"known project from a new one, so the derived slug stands as-is"
+            )
+        if failures is not None:
+            failures.append(type(exc).__name__)
         return False
 
 
-def _project_from_path(path: str) -> str:
-    """Derive a dotted-path project slug from a diary filename.
+def _derive_project(path: str) -> tuple[str, bool]:
+    """Derive a project slug from a diary filename, and say whether it resolved.
+
+    Returns ``(slug, resolved)``. ``resolved`` is True when some rung matched a
+    project the store already knows, and False when every rung fell through and
+    the raw slug is standing on its own. The caller needs that second value to
+    tell "this diary belongs to a known project" from "this diary is about to
+    mint a namespace nobody has ever seen", which is the distinction the summary
+    line now reports.
 
     ``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.
+    Three rungs, tried in order, first hit wins:
+
+    1. The raw slug, exactly. Checking raw FIRST is what keeps a project
+       genuinely named with a trailing number (``proj-2``) or a name that merely
+       looks like a suffix resolving to itself: a suffix is only ever stripped
+       when doing so turns an unknown name into a known one.
+    2. A trailing ``-<digits>`` stripped. The diary skill writes
+       ``{date}-{project}-N.md`` when a project already has a diary for that
+       date, and that ``-3`` used to become a separate project.
+    3. Trailing ``-segments`` stripped progressively, longest first. A diary
+       named ``{date}-{project}-{topic}.md`` -- the documented format is
+       ``{date}-{project}.md``, but descriptive names are written constantly --
+       filed every fact under ``{project}-{topic}``, invisible to any recall for
+       ``{project}``. ``foreman-turn-record`` tries ``foreman-turn``, then
+       ``foreman``. 495 facts across 37 phantom namespaces accumulated this way
+       before rung 3 existed.
+
+    Rung 3 is bounded by the segment count and never strips to empty, so the
+    last candidate it can offer is the first segment alone.
+
+    If nothing resolves the raw slug stands, exactly as before, and downstream
+    auto-registration handles the genuinely-new project -- but the caller now
+    knows to say so out loud.
+
+    Rung 3 is deliberately greedy, and that trades one silent failure for a
+    loud, correctable one: a genuinely distinct project whose name begins with
+    a known project's name (``deedstack-mobile`` alongside ``deedstack``) will
+    resolve to the shorter one and SAY it did. The escape hatch is the
+    ``--project`` flag, which skips derivation entirely.
     """
     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
+    # One list per derivation, so an unreachable store warns once, not per rung.
+    failures: list[str] = []
+
+    if _resolves(slug, failures):
+        return slug, True
 
     stripped = _SUFFIX_N.sub("", slug)
-    if stripped and stripped != slug and _resolves(stripped):
+    if stripped and stripped != slug and _resolves(stripped, failures):
         _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 stripped, True
+
+    # Rung 3: drop trailing '-segments' one at a time, longest candidate first.
+    # Bounded by the segment count; the loop stops with one segment left, so a
+    # candidate is never empty.
+    segments = slug.split("-")
+    for cut in range(len(segments) - 1, 0, -1):
+        candidate = "-".join(segments[:cut])
+        if candidate == stripped and stripped != slug:
+            continue  # rung 2 already asked about this exact name
+        if _resolves(candidate, failures):
+            _warn(
+                f"project {slug!r} is unknown but {candidate!r} is a known "
+                f"project -- ingesting under {candidate!r} (stripped a "
+                f"descriptive diary suffix)"
+            )
+            return candidate, True
+
+    return slug, False
+
 
-    return slug
+def _project_from_path(path: str) -> str:
+    """The derived slug alone, for callers that do not need the resolved flag."""
+    return _derive_project(path)[0]
 
 
 def _canonical_source_ref(path: str) -> str:
@@ -337,16 +415,27 @@ def _summary(
     }
 
 
-def _report(path: str, summary: dict) -> None:
+def _report(path: str, summary: dict, project: str, is_new: bool) -> 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.
+
+    The summary NAMES THE NAMESPACE IT WROTE TO. It did not, and that omission
+    is what let a whole class of misfiling stay invisible: every phantom-project
+    ingest printed a clean "N ingested" and exited 0, so the one number a reader
+    would have checked was correct and the one fact they needed was absent.
+    ``NEW`` marks a namespace no fact has ever been stored under, which is the
+    single cheapest signal that a derivation went somewhere unintended.
+
+    Everything stays on ONE line on purpose. A clean run must not emit a second
+    line, and must not put the word 'skipped' anywhere but the summary.
     """
+    label = f"NEW project {project!r}" if is_new else f"project {project!r}"
     print(
         f"{_PREFIX} {summary['ingested']} ingested, "
-        f"{summary['duplicates']} duplicate, {len(summary['skipped'])} skipped: "
-        f"{path}"
+        f"{summary['duplicates']} duplicate, {len(summary['skipped'])} skipped "
+        f"into {label}: {path}"
     )
     for reason in summary["skipped"]:
         print(f"  skipped {reason}")
@@ -359,13 +448,22 @@ def _report(path: str, summary: dict) -> None:
         )
 
 
-def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
+def ingest_diary_file(
+    path: str,
+    store: MemoryStore | None = None,
+    project: str | 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}``.
+    store_failure, exit_code, project}``.
+
+    ``project`` overrides filename derivation entirely and silently: an explicit
+    name is a decision already made, so there is nothing to warn about. It is
+    the escape hatch for a project whose real name looks like another project's
+    name plus a suffix, which rung 3 of the derivation would otherwise shorten.
     """
     try:
         text = Path(path).read_text(encoding="utf-8")
@@ -385,7 +483,29 @@ def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
 
     if store is None:
         store = MemoryStore()
-    project = _project_from_path(path)
+
+    if project:
+        # An explicit name is a decision already made: no derivation, no warning.
+        resolved = True
+    else:
+        project, resolved = _derive_project(path)
+
+    # "NEW" means no fact has EVER been stored under this namespace, asked
+    # before this run writes any. Deliberately a different question from
+    # _resolves, which consults the five legacy project_dir tables: a namespace
+    # that only ever held diary facts is invisible there, so it could never
+    # stop being "unknown" no matter how much it accumulated. This check reads
+    # memory_facts itself, so a phantom is announced once and only once.
+    is_new = False
+    if not resolved:
+        try:
+            is_new = store.stats(project=project)["total"] == 0
+        except Exception as exc:  # noqa: BLE001 -- never break the diary save
+            _warn(
+                f"could not check whether {project!r} is a new namespace "
+                f"({type(exc).__name__}); reporting it without the NEW marker"
+            )
+
     source_ref = _canonical_source_ref(path)
 
     skipped: list[str] = list(parsed.errors)   # malformed lines, already warned
@@ -437,26 +557,64 @@ def ingest_diary_file(path: str, store: MemoryStore | None = None) -> dict:
         skipped=skipped,
         store_failure=store_failure,
     )
-    _report(path, summary)
+    summary["project"] = project
+    _report(path, summary, project, is_new)
     return summary
 
 
+def _parse_argv(args: list[str]) -> tuple[str | None, str | None]:
+    """Split the CLI tail into ``(path, project)``. Never raises.
+
+    Accepts ``--project NAME`` and ``--project=NAME``. Unparseable input loses
+    nothing, so it warns and falls back to derivation rather than failing.
+    """
+    path: str | None = None
+    project: str | None = None
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--project":
+            if i + 1 < len(args) and args[i + 1] and not args[i + 1].startswith("--"):
+                project = args[i + 1]
+                i += 2
+                continue
+            _warn("--project needs a value; deriving the project from the filename")
+            i += 1
+            continue
+        if arg.startswith("--project="):
+            value = arg.split("=", 1)[1]
+            if value:
+                project = value
+            else:
+                _warn("--project needs a value; deriving the project from the filename")
+            i += 1
+            continue
+        if path is None:
+            path = arg
+        i += 1
+    return path, project
+
+
 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.
+    FAIL-OPEN CONTRACT in the module docstring. Nothing added here changes an
+    exit code: every new warning path is still 0.
+
+    Usage: ``diary_ingest <diary.md> [--project NAME]``
     """
-    if len(argv) < 2 or not argv[1]:
+    path, project = _parse_argv(list(argv[1:]))
+    if not path:
         # 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"]
+        return ingest_diary_file(path, project=project)["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}")
+        _warn(f"unexpected error ingesting {path!r}: {exc}")
         print(
             f"{_PREFIX} aborted, nothing ingested: {type(exc).__name__}: {exc}"
         )