memware 0.2.2__tar.gz → 0.2.5__tar.gz

{memware-0.2.2 → memware-0.2.5}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "memware",
       "source": "./integrations/claude-code",
       "description": "Session transcripts indexed for recall; a belief ledger that only remembers the latest truth. Hooks: SessionEnd/PreCompact sync, prompt-time belief context.",
-      "version": "0.1.1",
+      "version": "0.2.5",
       "author": {
         "name": "ericwalisko"
       }

{memware-0.2.2 → memware-0.2.5}/.gitignore

@@ -13,3 +13,6 @@ htmlcov/
 *.db-wal
 *.db-shm
 .memware/
+
+# uv lockfile (library, not committed)
+uv.lock

{memware-0.2.2 → memware-0.2.5}/CHANGELOG.md

@@ -6,7 +6,36 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
-## [0.2.2] - 2026-09-03
+## [0.2.5] - 2026-09-03
+
+### Added
+- `memware setup` is now a guided one-time walkthrough for both new installs and upgrades from
+  a pre-backup (pre-0.2) version: it offers to index the sessions already on disk, helps pick a
+  storage-agnostic backup destination, takes a first backup, and prints the operating guidance
+  (automatic session-end backups, `MEMWARE_NO_CAPTURE`, the wipe trap). `--yes` runs it
+  non-interactively. A one-line hint points anyone who has never configured backups at it, and
+  stops once setup has run or a destination is set.
+
+### Fixed
+- The Claude Code plugin manifest version was stuck at 0.1.1 across every release, so
+  `claude plugin update` compared 0.1.1 to 0.1.1 and never reinstalled — no plugin or hook
+  change (e.g. the 0.2.x automatic session-end backup hook) could reach an installed
+  machine. Both manifests now track the package version, enforced by
+  `tests/test_plugin_manifest.py` so it cannot silently drift again.
+
+## [0.2.4] - 2026-09-03
+
+### Fixed
+- Recall now collapses turns whose quoted text is **byte-identical** to a higher-ranked hit, so a
+  scheduled-automation prompt captured on many days takes one result slot instead of several. The
+  static skip-prefix list (a schema-v2 sweep) only catches harness-injected boilerplate; a user's
+  own repeated cron/system prompts are real turns it can never match. Collapse is a recall-time
+  view — every turn stays in the store, a session still reads back whole, and distinct findings
+  inside those sessions still surface. Deterministic, model-free; opt out with
+  `collapse_duplicates=False`.
+
+
+## [0.2.3] - 2026-09-03
 
 ### Fixed
 - Backup retention now **promotes**: a snapshot ages forward through the 1/3/7/14-day tiers

{memware-0.2.2 → memware-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memware
-Version: 0.2.2
+Version: 0.2.5
 Summary: Memory for AI agents that only remembers the latest truth: a bi-temporal belief ledger plus a transcript index, in one SQLite file.
 Project-URL: Homepage, https://github.com/ericwalisko/memware
 Project-URL: Issues, https://github.com/ericwalisko/memware/issues
@@ -122,6 +122,10 @@ sessions; index the transcripts already on disk so recall works over past work f
 memware backfill                 # indexes ~/.claude/projects (idempotent; ~5 s for a month)
 ```
 
+Prefer a guided first run? `memware setup` walks through the backfill and backups together and
+prints the operating guidance — safe on a fresh install and after upgrading from a pre-0.2
+(no-backups) version; `memware setup --yes` accepts the defaults non-interactively.
+
 The *belief ledger* starts empty and is not backfilled — beliefs are derived, not stored in
 transcripts. It fills as you work (via the `remember` tool, or a derive job you schedule).
 Transcript recall is what backfill gives you immediately, and it is where most of the value is.
@@ -164,6 +168,8 @@ expects), the same way it would issue a few grep or web-search queries:
 recall(queries=["which port does the api listen on", "api port", "8443", "gateway listen port"])
 ```
 
+Byte-identical hits collapse to a single slot, so a prompt captured on many days — a scheduled job's own preamble, say — never crowds out distinct evidence; the turns stay in the store and a session still reads back whole.
+
 Prompt-time injection (the hooks) stays deterministic and only injects beliefs whose
 *subject* the prompt names.
 
@@ -176,7 +182,7 @@ larger than the store. Once a destination is set, backups happen **automatically
 end (~once a day)** — no cron, and immune to a laptop sleeping through a scheduled time.
 
 ```bash
-memware setup                              # pick a folder: Dropbox / iCloud / Drive / external disk
+memware setup                              # guided: index sessions, pick a folder, take a first backup
 memware backup                             # tiered snapshot (1/3/7/14-day) + transcript mirror
 memware restore --latest                   # after a wipe, restore — do not re-backfill
 memware nuke                               # delete everything, typed-confirmation guarded

{memware-0.2.2 → memware-0.2.5}/README.md

@@ -91,6 +91,10 @@ sessions; index the transcripts already on disk so recall works over past work f
 memware backfill                 # indexes ~/.claude/projects (idempotent; ~5 s for a month)
 ```
 
+Prefer a guided first run? `memware setup` walks through the backfill and backups together and
+prints the operating guidance — safe on a fresh install and after upgrading from a pre-0.2
+(no-backups) version; `memware setup --yes` accepts the defaults non-interactively.
+
 The *belief ledger* starts empty and is not backfilled — beliefs are derived, not stored in
 transcripts. It fills as you work (via the `remember` tool, or a derive job you schedule).
 Transcript recall is what backfill gives you immediately, and it is where most of the value is.
@@ -133,6 +137,8 @@ expects), the same way it would issue a few grep or web-search queries:
 recall(queries=["which port does the api listen on", "api port", "8443", "gateway listen port"])
 ```
 
+Byte-identical hits collapse to a single slot, so a prompt captured on many days — a scheduled job's own preamble, say — never crowds out distinct evidence; the turns stay in the store and a session still reads back whole.
+
 Prompt-time injection (the hooks) stays deterministic and only injects beliefs whose
 *subject* the prompt names.
 
@@ -145,7 +151,7 @@ larger than the store. Once a destination is set, backups happen **automatically
 end (~once a day)** — no cron, and immune to a laptop sleeping through a scheduled time.
 
 ```bash
-memware setup                              # pick a folder: Dropbox / iCloud / Drive / external disk
+memware setup                              # guided: index sessions, pick a folder, take a first backup
 memware backup                             # tiered snapshot (1/3/7/14-day) + transcript mirror
 memware restore --latest                   # after a wipe, restore — do not re-backfill
 memware nuke                               # delete everything, typed-confirmation guarded

{memware-0.2.2 → memware-0.2.5}/RELEASING.md

@@ -71,13 +71,23 @@ Troubleshooting below.
 
 ## Cutting a release
 
-1. **Bump the version.** It lives in exactly one place:
+1. **Bump the version.** The package version lives in:
 
    ```
    src/memware/__init__.py   →   __version__ = "0.1.1"
    ```
 
-   `pyproject.toml` reads it via `[tool.hatch.version]`, so nothing else needs editing.
+   `pyproject.toml` reads it via `[tool.hatch.version]`. The Claude Code plugin also carries
+   its own copy of the version in two manifests, and `tests/test_plugin_manifest.py` fails CI
+   unless both equal the package version — so bump all three together:
+
+   ```
+   integrations/claude-code/.claude-plugin/plugin.json   →   "version"
+   .claude-plugin/marketplace.json                       →   plugins[memware].version
+   ```
+
+   `claude plugin update` only reinstalls when the manifest version rises, so a plugin or hook
+   change that skips this bump never reaches an installed machine.
 
 2. **Cut the CHANGELOG.** Move the `## [Unreleased]` entries under a new
    `## [X.Y.Z] - YYYY-MM-DD` heading and leave `## [Unreleased]` empty above it.

{memware-0.2.2 → memware-0.2.5}/docs/backup.md

@@ -21,7 +21,10 @@ wipe, **restore from a backup — do not re-backfill.** memware helps:
 A destination is just a folder. Point it at whatever you already sync or keep:
 
 ```bash
-memware setup          # interactive: asks for the folder, offers transcript mirroring
+memware setup          # guided walkthrough: indexes existing sessions (new installs),
+                       # picks a folder, offers transcript mirroring, takes a first backup.
+                       # Run it on a fresh install or after upgrading from a pre-0.2 version;
+                       # `memware setup --yes` accepts defaults non-interactively.
 # or set it directly:
 memware config backup.dest "~/Dropbox/memware"        # or ~/Library/Mobile Documents/…/memware,
                                                        # ~/Google Drive/memware, /Volumes/backup/memware

{memware-0.2.2 → memware-0.2.5}/integrations/claude-code/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "memware",
   "description": "Session transcripts indexed for recall; a belief ledger that only remembers the latest truth.",
-  "version": "0.1.1",
+  "version": "0.2.5",
   "author": {
     "name": "ericwalisko"
   }

{memware-0.2.2 → memware-0.2.5}/src/memware/__init__.py

@@ -22,4 +22,4 @@ __all__ = [
     "history",
     "reject",
 ]
-__version__ = "0.2.2"
+__version__ = "0.2.5"

{memware-0.2.2 → memware-0.2.5}/src/memware/backup.py

@@ -13,6 +13,7 @@ import re
 import shutil
 import sqlite3
 from datetime import UTC, datetime
+from itertools import pairwise
 from pathlib import Path
 
 SNAPSHOT_GLOB = "memware-*.db"
@@ -84,7 +85,7 @@ def apply_retention(dest_dir: str | os.PathLike[str], keep_days: list[int]) -> l
     days = sorted(set(int(d) for d in keep_days))
     keep: set[Path] = {snaps[0]}  # always the freshest
     edges = [0.0, *[float(d) for d in days]]
-    for lo, hi in zip(edges, edges[1:], strict=False):
+    for lo, hi in pairwise(edges):
         band = [p for p in snaps if lo < _age_days(p, now) <= hi]
         if band:
             keep.add(band[-1])  # oldest in the band (snaps are newest-first) -> promotes forward

{memware-0.2.2 → memware-0.2.5}/src/memware/cli.py

@@ -40,6 +40,7 @@ def _out(obj: object, as_json: bool) -> None:
 
 
 def cmd_init(a: argparse.Namespace) -> int:
+    _maybe_setup_hint(a)
     with Store(a.db) as s:
         _out({"db": str(s.path), **s.stats()}, a.json)
     return 0
@@ -117,6 +118,7 @@ def cmd_backfill(a: argparse.Namespace) -> int:
     The plugin only captures new sessions; this reads what is already on disk.
     Idempotent — safe to re-run — and it honours the ignore-markers list.
     """
+    _maybe_setup_hint(a)
     root = Path(a.root).expanduser()
     if not root.exists():
         print(f"nothing to backfill: {root} does not exist", file=sys.stderr)
@@ -267,6 +269,7 @@ def cmd_prune(a: argparse.Namespace) -> int:
 
 
 def cmd_stats(a: argparse.Namespace) -> int:
+    _maybe_setup_hint(a)
     with Store(a.db) as s:
         _out({"db": str(s.path), **s.stats()}, a.json)
     return 0
@@ -344,37 +347,122 @@ def cmd_restore(a: argparse.Namespace) -> int:
     return 0
 
 
+def _prompt(msg: str, default: str = "") -> str:
+    """input() that returns ``default`` on a closed stdin, so setup is safe non-interactively."""
+    try:
+        return input(msg).strip()
+    except EOFError:
+        return default
+
+
+def _yes(msg: str, *, default_yes: bool = True) -> bool:
+    ans = _prompt(f"{msg} {'[Y/n]' if default_yes else '[y/N]'}: ").lower()
+    return default_yes if not ans else ans[0] == "y"
+
+
+def _maybe_setup_hint(a: argparse.Namespace) -> None:
+    """A one-line nudge to `memware setup` for anyone who has never configured backups — new
+    installs and upgrades from a pre-backup (pre-0.2) version alike. Silent from hooks and in
+    --json mode; stops as soon as setup has run or a destination is configured."""
+    from memware.config import get_dotted, load_config
+
+    if getattr(a, "from_hook", False) or getattr(a, "json", False):
+        return
+    cfg = load_config()
+    if get_dotted(cfg, "setup.completed_version") or get_dotted(cfg, "backup.dest"):
+        return
+    print(
+        "Tip: run `memware setup` to configure backups (one time; this hint then stops).",
+        file=sys.stderr,
+    )
+
+
 def cmd_setup(a: argparse.Namespace) -> int:
-    """Interactive first-run guidance for the backup destination (storage-agnostic)."""
+    """Guided one-time configuration: index the sessions already on disk (new installs),
+    choose a backup destination, run a first backup, and print the operating guidance. Safe to
+    re-run, and safe non-interactive — a closed stdin (or ``--yes``) keeps every current value.
+    Covers a fresh install and an upgrade from a pre-backup (pre-0.2) version alike."""
+    from memware import backup as bk
     from memware.config import get_dotted, load_config, save_config, set_dotted
 
     cfg = load_config()
+    yes = getattr(a, "yes", False)
+    src_default = get_dotted(cfg, "backup.transcript_src") or "~/.claude/projects"
+
+    with Store(a.db) as s:
+        stats = s.stats()
+    fresh = stats["turns"] == 0
+    print("memware setup\n")
+    if fresh:
+        print("This store is empty. The plugin captures new sessions from now on; you can also")
+        print("index the transcripts already on disk so recall works over past work today.")
+    else:
+        print(f"This store holds {stats['turns']:,} turns from {stats['sessions']:,} sessions.")
+        print("Let's make sure backups are configured so an aged session can't be lost.")
+
+    # 1. Backfill existing transcripts (mainly a fresh install / new machine).
+    root = Path(src_default).expanduser()
+    if (
+        fresh
+        and root.exists()
+        and (yes or _yes(f"\nIndex existing sessions in {src_default} now?"))
+    ):
+        with Store(a.db) as s:
+            report = sync_tree(s, root, harness="claude-code")
+            stats = s.stats()
+        print(
+            f"  indexed {sum(report.values()):,} turns from {len(report)} files "
+            f"({stats['sessions']:,} sessions)."
+        )
+
+    # 2. Backup destination.
+    print("\nBackups: pick a folder your OS already syncs, or a drive you keep — memware just")
+    print("writes there (Dropbox, iCloud Drive, Google Drive, an external disk, a network mount).")
+    print("Snapshots are a rolling 1/3/7/14-day set you can revert to; raw transcripts are")
+    print("mirrored separately so a session outlives your OS's ~30-day transcript cleanup.")
     cur = get_dotted(cfg, "backup.dest")
-    print("memware backup setup")
-    print("  Pick a folder your OS already syncs or a drive you keep — memware just writes")
-    print(
-        "  snapshots there. Examples: ~/Dropbox/memware, ~/Library/Mobile Documents/com~apple~CloudDocs/memware,"
-    )
-    print("  ~/Google Drive/memware, /Volumes/backup/memware.")
     if cur:
         print(f"  Current: {cur}")
-    try:
-        dest = input("Backup folder (blank to keep current): ").strip()
-    except EOFError:
-        dest = ""
+    dest = "" if yes else _prompt("Backup folder (blank to keep current / skip): ")
     if dest:
         set_dotted(cfg, "backup.dest", dest)
-    try:
-        t = (
-            input("Also mirror transcripts there so they outlive the 30-day cleanup? [Y/n]: ")
-            .strip()
-            .lower()
+    dest = get_dotted(cfg, "backup.dest")
+    if dest:
+        set_dotted(
+            cfg,
+            "backup.include_transcripts",
+            True if yes else _yes("Also mirror raw transcripts there (recommended)?"),
         )
-    except EOFError:
-        t = ""
-    set_dotted(cfg, "backup.include_transcripts", t != "n")
-    path = save_config(cfg)
-    print(f"\nSaved {path}. Run `memware backup` now, and schedule it daily (see docs/backup.md).")
+
+    # 3. Persist, and mark setup done so the discovery hint stops.
+    set_dotted(cfg, "setup.completed_version", __version__)
+    print(f"\nSaved {save_config(cfg)}.")
+
+    # 4. Offer a first backup right now.
+    if dest and (yes or _yes("Run a first backup now?")):
+        dpath = Path(dest).expanduser()
+        out = bk.snapshot(a.db, dpath)
+        bk.apply_retention(dpath, get_dotted(cfg, "backup.keep_days") or [1, 3, 7, 14])
+        n = (
+            bk.mirror_transcripts(get_dotted(cfg, "backup.transcript_src") or src_default, dpath)
+            if get_dotted(cfg, "backup.include_transcripts")
+            else 0
+        )
+        print(f"  snapshot {Path(out).name}" + (f", {n} transcripts mirrored" if n else ""))
+
+    # 5. Operating guidance.
+    print("\nHow backups keep running:")
+    if dest:
+        print("  • The Claude Code plugin backs up at session end, at most once every ~20h — no")
+        print("    cron, and never missed by a laptop sleeping through a scheduled time.")
+        print("  • Always-on machine without the plugin? Schedule `memware backup` (launchd on")
+        print("    macOS, systemd on Linux; avoid plain cron on a laptop). See docs/backup.md.")
+    else:
+        print("  • No destination set — recall still works, but there's no wipe-trap safety net.")
+        print("    Re-run `memware setup` any time to add one.")
+    print("  • Sensitive session? Set MEMWARE_NO_CAPTURE=1 and it is never indexed.")
+    print("  • After a wipe, `memware restore --latest` — never wipe-and-re-backfill (backfill")
+    print("    only re-indexes transcripts still on disk). See docs/backup.md.")
     return 0
 
 
@@ -596,7 +684,8 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("--dest", metavar="DIR", help="backup destination to pick the latest from")
     s.set_defaults(fn=cmd_restore)
 
-    s = add("setup", "interactive one-time backup setup (storage-agnostic)")
+    s = add("setup", "guided one-time setup: index existing sessions, configure backups")
+    s.add_argument("--yes", action="store_true", help="accept defaults; non-interactive")
     s.set_defaults(fn=cmd_setup)
 
     s = add("config", "show or set configuration (e.g. backup.dest, backup.keep_days)")

{memware-0.2.2 → memware-0.2.5}/src/memware/index.py

@@ -14,6 +14,11 @@ BM25 runs over *passages* (see :mod:`memware.passage`), not whole turns, while
 activation stays the turn's — recency and use belong to the conversation. Hits
 collapse to one per turn and quote only the matching passages, so recall costs
 roughly a third fewer tokens; reading a session back still returns whole turns.
+
+Results also collapse across turns whose quoted text is byte-identical — the same
+scheduled-automation prompt captured on many days would otherwise take several slots
+with copies of one string. The highest-ranked copy is kept; the turns themselves stay
+in the store, so a session still reads back whole and distinct findings still surface.
 """
 
 from __future__ import annotations
@@ -174,6 +179,7 @@ def search_turns(
     record_use: bool = True,
     snippet_tokens: int = 96,
     passages_per_turn: int = 3,
+    collapse_duplicates: bool = True,
 ) -> list[Hit]:
     """Top-k turns by BM25 x activation, each ranked on its best passage.
 
@@ -208,16 +214,25 @@ def search_turns(
         score = r["rel"] * activation(r["ts"], r["use_count"], decay=decay, use_weight=use_weight)
         scored.setdefault(r["turn_id"], []).append((score, r))
     hits: list[Hit] = []
-    for turn_id in sorted(scored, key=lambda t: -max(s for s, _ in scored[t]))[:k]:
+    seen_text: set[str] = set()
+    for turn_id in sorted(scored, key=lambda t: -max(s for s, _ in scored[t])):
+        if len(hits) >= k:
+            break
         by_score = sorted(scored[turn_id], key=lambda sr: -sr[0])
         keep = sorted(by_score[: max(1, passages_per_turn)], key=lambda sr: sr[1]["ord"])
+        text = _join_passages([r for _, r in keep])
+        if collapse_duplicates:
+            sig = text.strip()
+            if sig in seen_text:
+                continue  # byte-identical to a higher-ranked hit (e.g. a repeated cron prompt)
+            seen_text.add(sig)
         best = by_score[0][1]
         hits.append(
             Hit(
                 id=turn_id,
                 kind="turn",
                 score=by_score[0][0],
-                text=_join_passages([r for _, r in keep]),
+                text=text,
                 session=best["session"],
                 ts=best["ts"],
                 role=best["role"],
@@ -313,6 +328,25 @@ def _rrf(ranked_lists: list[list[Hit]], k: int, c: int = 60) -> list[Hit]:
     return [best[kk] for kk in order]
 
 
+def _collapse_identical(hits: list[Hit], k: int) -> list[Hit]:
+    """Drop turn hits whose quoted text is byte-identical to a higher-ranked one, then take the
+    first ``k``. Non-turn hits pass through. This is the cross-phrasing counterpart to the
+    per-query collapse in :func:`search_turns`: reciprocal-rank fusion keys on ``(kind, id)``,
+    so two different turns holding the same repeated text would otherwise both survive."""
+    seen: set[str] = set()
+    out: list[Hit] = []
+    for h in hits:
+        if h.kind == "turn":
+            sig = h.text.strip()
+            if sig in seen:
+                continue
+            seen.add(sig)
+        out.append(h)
+        if len(out) >= k:
+            break
+    return out
+
+
 def search_turns_multi(
     store: Store,
     queries: list[str],
@@ -334,8 +368,10 @@ def search_turns_multi(
         return []
     if len(seen) == 1:
         return search_turns(store, seen[0], k=k, record_use=record_use, **kw)  # type: ignore[arg-type]
+    collapse = bool(kw.get("collapse_duplicates", True))
     lists = [search_turns(store, q, k=max(k, 20), record_use=False, **kw) for q in seen]  # type: ignore[arg-type]
-    fused = _rrf(lists, k)
+    fused = _rrf(lists, max(k * 3, 30) if collapse else k)
+    fused = _collapse_identical(fused, k) if collapse else fused[:k]
     if record_use and fused:
         ts = now_iso()
         store.conn.executemany(

{memware-0.2.2 → memware-0.2.5}/tests/test_cli.py

@@ -59,3 +59,51 @@ def test_backfill_indexes_existing_transcripts(tmp_path, capsys):
     # idempotent
     assert main(["--db", db, "backfill", str(tmp_path / "projects"), "--json"]) == 0
     assert json.loads(capsys.readouterr().out)["turns_added"] == 0
+
+
+def test_setup_yes_backfills_and_makes_first_backup(tmp_path, capsys, monkeypatch):
+    """A fresh-install walkthrough end to end: --yes indexes the sessions already on disk and
+    takes a first backup, and it marks setup done so the discovery hint stops."""
+    from memware import __version__
+    from memware import backup as bk
+    from memware.config import get_dotted, load_config
+
+    monkeypatch.setenv("MEMWARE_HOME", str(tmp_path / "home"))
+    projects = tmp_path / "projects"
+    (projects / "p").mkdir(parents=True)
+    write_claude_jsonl(
+        projects / "p" / "s.jsonl",
+        "s",
+        [("assistant", "2026-08-20T00:00:00Z", "the nightly job compacts the write-ahead log")],
+    )
+    dest = tmp_path / "dropbox" / "memware"
+    db = str(tmp_path / "m.db")
+    for k, v in (("backup.transcript_src", str(projects)), ("backup.dest", str(dest))):
+        main(["--db", db, "config", k, str(v)])
+    capsys.readouterr()
+
+    assert main(["--db", db, "setup", "--yes"]) == 0
+    out = capsys.readouterr().out
+    assert "indexed 1 turns" in out
+
+    assert main(["--db", db, "stats", "--json"]) == 0
+    assert json.loads(capsys.readouterr().out)["turns"] == 1  # backfill happened
+    assert get_dotted(load_config(), "setup.completed_version") == __version__
+    assert bk.list_snapshots(dest)  # a first snapshot was taken
+    assert (dest / "transcripts" / "p" / "s.jsonl").exists()  # transcripts mirrored
+
+
+def test_setup_hint_shows_until_backups_configured(tmp_path, capsys, monkeypatch):
+    monkeypatch.setenv("MEMWARE_HOME", str(tmp_path / "home"))
+    db = str(tmp_path / "m.db")
+
+    main(["--db", db, "stats"])  # never set up -> the tip appears on stderr
+    assert "memware setup" in capsys.readouterr().err
+
+    main(["--db", db, "stats", "--json"])  # machine-readable callers never see it
+    assert "memware setup" not in capsys.readouterr().err
+
+    main(["--db", db, "config", "backup.dest", str(tmp_path / "bk")])
+    capsys.readouterr()
+    main(["--db", db, "stats"])  # once a destination exists the tip is gone
+    assert "memware setup" not in capsys.readouterr().err

{memware-0.2.2 → memware-0.2.5}/tests/test_hermes_upstream_plugin.py

@@ -131,10 +131,12 @@ def test_a_turn_is_captured_and_recallable(provider, tmp_path):
 
 def test_a_session_switch_keeps_each_session_separate(provider, tmp_path):
     """Turns must land in the session that was live when they happened."""
-    provider.sync_turn("how is the scheduler wired", "the scheduler polls a work queue")
+    provider.sync_turn(
+        "how is the scheduler wired", "the scheduler polls a work queue every second"
+    )
     provider.shutdown()
     provider.on_session_switch("sess-2")
-    provider.sync_turn("how is the scheduler wired", "the scheduler polls a work queue")
+    provider.sync_turn("how is the scheduler wired", "the scheduler drains a work queue in batches")
     provider.shutdown()
 
     hits = json.loads(

{memware-0.2.2 → memware-0.2.5}/tests/test_index.py

@@ -21,12 +21,12 @@ def test_turn_recall_ranks_recent_higher_and_records_use(store, tmp_path):
     write_claude_jsonl(
         old,
         "old",
-        [("assistant", "2024-01-01T00:00:00Z", "deploy uses the blue-green rollout script")],
+        [("assistant", "2024-01-01T00:00:00Z", "the old deploy ran a blue-green rollout script")],
     )
     write_claude_jsonl(
         new,
         "new",
-        [("assistant", "2026-08-30T00:00:00Z", "deploy uses the blue-green rollout script")],
+        [("assistant", "2026-08-30T00:00:00Z", "the new deploy runs a blue-green rollout script")],
     )
     sync_file(store, old, harness="claude-code")
     sync_file(store, new, harness="claude-code")
@@ -191,3 +191,36 @@ def test_multi_query_fusion_finds_what_single_phrasings_rank_low(store, tmp_path
     )
     assert "8443" in fused[0].text
     assert search_turns_multi(store, ["", "  "], k=3) == []
+
+
+def _write_turn(tmp_path, session, text, ts="2026-09-01T00:00:00Z"):
+    from tests.conftest import write_claude_jsonl
+
+    p = tmp_path / f"{session}.jsonl"
+    write_claude_jsonl(p, session, [("assistant", ts, text)])
+    return p
+
+
+def test_recall_collapses_byte_identical_turns_but_keeps_distinct_findings(store, tmp_path):
+    """A scheduled prompt captured on several days is one string repeated across turns; it
+    should take a single result slot, not crowd out real evidence. Distinct findings that merely
+    share vocabulary must still surface, and every turn stays in the store."""
+    boiler = "you are the nightly drift scan for the pcc runbooks, review each entry"
+    for day in ("d1", "d2", "d3"):  # byte-identical cron prompt, three days
+        sync_file(store, _write_turn(tmp_path, day, boiler), harness="claude-code")
+    sync_file(  # a real finding from one of those runs — shares vocabulary, different text
+        store,
+        _write_turn(
+            tmp_path, "finding", "the nightly drift scan found a stale runbooks entry to fix"
+        ),
+        harness="claude-code",
+    )
+
+    collapsed = search_turns(store, "nightly drift scan runbooks", k=5)
+    assert len(collapsed) == 2  # the repeated prompt -> one slot, plus the distinct finding
+    assert any("stale runbooks entry" in h.text for h in collapsed)  # finding not crowded out
+
+    raw = search_turns(store, "nightly drift scan runbooks", k=5, collapse_duplicates=False)
+    assert sum(1 for h in raw if h.text.strip() == boiler) == 3  # opt out -> copies return
+
+    assert store.stats()["turns"] == 4  # collapse is a recall-time view; nothing was deleted

memware-0.2.5/tests/test_plugin_manifest.py

@@ -0,0 +1,24 @@
+"""The Claude Code plugin carries its own version string, and `claude plugin update` only
+reinstalls when it rises. Nothing in the release path enforced it, so it silently sat at 0.1.1
+across many releases and no hook change ever reached an installed machine. These tests keep both
+manifests equal to the package version, so cutting a release always moves the plugin too."""
+
+import json
+from pathlib import Path
+
+import memware
+
+ROOT = Path(__file__).resolve().parents[1]
+PLUGIN = ROOT / "integrations" / "claude-code" / ".claude-plugin" / "plugin.json"
+MARKETPLACE = ROOT / ".claude-plugin" / "marketplace.json"
+
+
+def test_plugin_manifest_version_matches_package():
+    plugin = json.loads(PLUGIN.read_text())
+    assert plugin["version"] == memware.__version__, (plugin["version"], memware.__version__)
+
+
+def test_marketplace_plugin_version_matches_package():
+    market = json.loads(MARKETPLACE.read_text())
+    entry = next(p for p in market["plugins"] if p["name"] == "memware")
+    assert entry["version"] == memware.__version__, (entry["version"], memware.__version__)