compartment 3.2__tar.gz → 3.3__tar.gz

{compartment-3.2 → compartment-3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compartment
-Version: 3.2
+Version: 3.3
 Summary: Compartment - high-security, fully offline, encrypted vector memory for AI agents (MCP)
 Project-URL: Homepage, https://github.com/MaxFreedomPollard/Compartment
 Project-URL: Source, https://github.com/MaxFreedomPollard/Compartment

{compartment-3.2 → compartment-3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compartment"
-version = "3.2"
+version = "3.3"
 description = "Compartment - high-security, fully offline, encrypted vector memory for AI agents (MCP)"
 readme = "README.md"
 requires-python = ">=3.11"

{compartment-3.2 → compartment-3.3}/src/compartment/__init__.py

@@ -1,6 +1,6 @@
 """Compartment - high-security, fully offline, encrypted vector memory for AI agents."""
 
-__version__ = "3.2"
+__version__ = "3.3"
 
 from . import offline_guard as _og
 

{compartment-3.2 → compartment-3.3}/src/compartment/acl.py

@@ -25,6 +25,7 @@ DEFAULT_CONFIG = {
     "settings": {
         "auto_lock_minutes": 30,
         "include_packs_in_search": True,
+        "search_starter_facts": True,
         "unlock_tool_enabled": False,
         "duplicate_threshold": 0.97,
         "index_precision": "f32",

{compartment-3.2 → compartment-3.3}/src/compartment/cli.py

@@ -86,11 +86,23 @@ def _pack_bytes(name: str) -> bytes | None:
     return p.read_bytes() if p.is_file() else None
 
 
-def _seed_pack_bytes() -> bytes:
-    b = _pack_bytes("starter")
-    if b is None:
-        raise CryptoError("Bundled starter.mpack is missing from this install")
-    return b
+def _seed_blobs() -> list[tuple[str, bytes]]:
+    """The starting memories, or a hard failure.
+
+    They are part of every install, command line or app, so an install that
+    cannot produce them is broken and has to say so. Returning nothing here
+    would create a vault that is empty but looks finished, which is the one
+    outcome a new user cannot diagnose."""
+    out = []
+    for name in _starter_pack_names():
+        blob = _pack_bytes(name)
+        if blob is None:
+            _die(f"this install is incomplete: {name}.mpack is missing from "
+                 f"{_data_dir()}. The starting memories ship with every "
+                 "install - reinstall Compartment rather than start with an "
+                 "empty vault.")
+        out.append((name, blob))
+    return out
 
 
 def _starter_pack_names() -> list[str]:
@@ -112,6 +124,9 @@ def cmd_init(args) -> None:
     Path(path).parent.mkdir(parents=True, exist_ok=True)
     if os.path.exists(path):
         _die(f"{path} already exists - Compartment never overwrites a vault")
+    # Before a passphrase is chosen and before anything reaches disk: a broken
+    # install fails here, with nothing to clean up.
+    seeds = _seed_blobs()
     print(f"Compartment {__version__} - creating vault: {path}")
     print(f"Embedding model: {DEFAULT_MODEL} (bundled, offline)")
     if args.passphrase:
@@ -131,10 +146,7 @@ def cmd_init(args) -> None:
     print("(Optional second factor: `compartment 2fa enable` - see README.)")
     print("\nFinishing vault setup (offline)…")
     total = 0
-    for name in _starter_pack_names():
-        blob = _pack_bytes(name)
-        if blob is None:
-            continue
+    for _, blob in seeds:
         out = packs.seed_records(v, blob, caller=args.creator)
         total += out["records"]
         nrec = out["records"]
@@ -450,8 +462,16 @@ def cmd_recent(args) -> None:
         print(f"{counts['total']} records | {counts['organic']} organic "
               f"(stored during use) | {counts['seeded']} seeded")
         if not out["results"]:
-            print("\nno memories stored yet"
-                  + ("" if args.all else " (starter facts hidden; --all shows them)"))
+            # A fresh vault is not an empty one. Saying "no memories" to
+            # someone who just watched several thousand load is how a working
+            # install gets mistaken for a broken one.
+            if counts["seeded"] and not args.all:
+                print(f"\nnothing stored during use yet. The "
+                      f"{counts['seeded']:,} starting memories that came with "
+                      f"the vault are loaded and searchable - list them with "
+                      f"`compartment recent --all`.")
+            else:
+                print("\nno memories stored yet")
         else:
             print(f"\n{len(out['results'])} most recent, oldest first:\n")
         for r in out["results"]:

{compartment-3.2 → compartment-3.3}/src/compartment/menubar.py

@@ -146,7 +146,7 @@ def read_settings(vault: str) -> dict:
     return {
         "capture_hook": hook,
         "search_starter_facts": bool(
-            cfg.settings.get("include_packs_in_search", True)),
+            cfg.settings.get("search_starter_facts", True)),
         "auto_lock_minutes": int(cfg.settings.get("auto_lock_minutes", 30)),
     }
 
@@ -162,7 +162,7 @@ def set_setting(vault: str, key: str, value) -> dict:
         return read_settings(vault)
     cfg = VaultConfig.load(vault)
     if key == "search_starter_facts":
-        cfg.settings["include_packs_in_search"] = bool(value)
+        cfg.settings["search_starter_facts"] = bool(value)
     elif key == "auto_lock_minutes":
         cfg.settings["auto_lock_minutes"] = int(value)
     else:
@@ -289,6 +289,19 @@ def summarise(state: dict) -> str:
             f"{state['organic']:,} stored by you")
 
 
+def starter_note(state: dict) -> str:
+    """What the recent list says when nothing has been stored during use.
+
+    A new vault holds thousands of starting memories and no organic ones, so
+    the recent feed is legitimately empty on day one. "Nothing yet" there
+    reads as an empty vault, which is the opposite of what happened."""
+    seeded = max(int(state.get("records", 0)) - int(state.get("organic", 0)), 0)
+    if not seeded:
+        return "nothing stored yet"
+    return (f"nothing stored during use yet - {seeded:,} starting memories "
+            "came with the vault and are searchable now")
+
+
 def auto_lock_label(minutes: int) -> str:
     return "Never" if not minutes else f"{minutes} min"
 
@@ -730,7 +743,8 @@ def run(vault: str | None = None, show: bool = False,
                 views.append(label("unlock the vault to see them", 11,
                                    secondary=True))
             elif not st["recent"]:
-                views.append(label("nothing stored yet", 11, secondary=True))
+                views.append(label(starter_note(st), 11, secondary=True,
+                                   wrap=True))
             else:
                 for r in st["recent"]:
                     text = " ".join((r.get("text") or "").split())

{compartment-3.2 → compartment-3.3}/src/compartment/systray.py

@@ -32,7 +32,7 @@ from .home import env, home
 from .menubar import (AUTO_LOCK_CHOICES, RECENT_COUNT, auto_lock_label,
                       change_passphrase, claim_first_run, default_vault,
                       fetch_state, lock_vault, self_check, set_setting,
-                      summarise, unlock_vault)
+                      starter_note, summarise, unlock_vault)
 
 PANEL_WIDTH = 360
 PANEL_MAX_HEIGHT = 640
@@ -109,7 +109,7 @@ def panel_rows(state: dict) -> list[tuple[str, str]]:
     rows.append(("heading", f"LAST {RECENT_COUNT} MEMORIES"))
     recent = state.get("recent") or []
     if not recent:
-        rows.append(("empty", "Nothing yet."))
+        rows.append(("empty", starter_note(state)))
     for r in recent:
         rows.append(("memory", (r.get("text") or "").strip()))
     return rows

{compartment-3.2 → compartment-3.3}/src/compartment/vault.py

@@ -61,6 +61,15 @@ QUARANTINE_WARNING = (
 )
 
 
+def is_seeded(tags_json: str) -> bool:
+    """Did this record arrive with the vault, rather than during use?
+
+    Seeding preserves each starting memory's stable id as an "id:" tag, and
+    nothing else writes one, so the tag is the mark. It is the same test
+    everywhere a caller asks to see one set without the other."""
+    return any(t.startswith("id:") for t in json.loads(tags_json))
+
+
 class VaultLockedError(CryptoError):
     pass
 
@@ -503,11 +512,19 @@ class Vault:
                    + IMPORTANCE_WEIGHT * self._importance_of(rid)
                    for rid, s in scores.items()}
 
+        # The starting memories are ordinary records in "main", so a namespace
+        # filter cannot reach them. Anyone who wants recall limited to what the
+        # agent learned here turns them off, and that has to be honoured on the
+        # one path that returns memories to a model.
+        starter = self.config.settings.get("search_starter_facts", True)
+
         results = []
         for rid in sorted(boosted, key=boosted.get, reverse=True):
             row = self.db.get_row(rid)
             if row is None or row["ns"] not in allowed:
                 continue
+            if not starter and is_seeded(row["tags"]):
+                continue
             if tags and not set(tags) <= set(json.loads(row["tags"])):
                 continue
             if since and row["created"] < since:
@@ -564,7 +581,7 @@ class Vault:
             if row["ns"] not in allowed:
                 continue
             total += 1
-            seeded = any(t.startswith("id:") for t in json.loads(row["tags"]))
+            seeded = is_seeded(row["tags"])
             if not seeded:
                 organic += 1
             if seeded and not include_seeded:

{compartment-3.2 → compartment-3.3}/src/compartment.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compartment
-Version: 3.2
+Version: 3.3
 Summary: Compartment - high-security, fully offline, encrypted vector memory for AI agents (MCP)
 Project-URL: Homepage, https://github.com/MaxFreedomPollard/Compartment
 Project-URL: Source, https://github.com/MaxFreedomPollard/Compartment

{compartment-3.2 → compartment-3.3}/src/compartment.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ tests/test_session_entropy.py
 tests/test_session_lock.py
 tests/test_starter_data_quality.py
 tests/test_starter_packs.py
+tests/test_starter_visibility.py
 tests/test_status_bar_install.py
 tests/test_systray.py
 tests/test_tamper.py

{compartment-3.2 → compartment-3.3}/tests/test_menubar.py

@@ -43,7 +43,7 @@ def test_set_setting_persists_to_the_config_file(vault_path, monkeypatch):
     menubar.set_setting(vault_path, "search_starter_facts", False)
     menubar.set_setting(vault_path, "auto_lock_minutes", 0)
     cfg = VaultConfig.load(vault_path)          # straight from disk
-    assert cfg.settings["include_packs_in_search"] is False
+    assert cfg.settings["search_starter_facts"] is False
     assert cfg.settings["auto_lock_minutes"] == 0
     again = menubar.read_settings(vault_path)
     assert again["search_starter_facts"] is False

compartment-3.3/tests/test_starter_visibility.py

@@ -0,0 +1,197 @@
+"""The starting memories arrive with every install, and every surface says so.
+
+Two separate failures hide behind "where are the starter memories?". One is an
+install that never seeded and said nothing about it. The other is an install
+that seeded perfectly and then reported itself as empty, because the recent
+feed hides seeded records by design. Both look identical to the person who
+just installed it, so both are tested here.
+"""
+import json
+import pathlib
+
+import pytest
+
+from compartment import cli, menubar, packs
+from compartment.acl import VaultConfig
+from compartment.vault import Vault, is_seeded
+
+DATA = pathlib.Path(__file__).resolve().parents[1] / "src" / "compartment" / "data"
+PASS = "CorrectHorse"
+
+
+# --------------------------------------------------------------- the install
+
+def test_a_missing_starter_pack_is_a_hard_failure(monkeypatch, tmp_path):
+    """Never quietly hand back an empty vault."""
+    monkeypatch.setattr(cli, "_data_dir", lambda: tmp_path / "not-here")
+    with pytest.raises(SystemExit):
+        cli._seed_blobs()
+
+
+def test_the_failure_names_the_remedy(monkeypatch, tmp_path, capsys):
+    monkeypatch.setattr(cli, "_data_dir", lambda: tmp_path / "not-here")
+    with pytest.raises(SystemExit):
+        cli._seed_blobs()
+    err = capsys.readouterr().err
+    assert "starter.mpack" in err and "reinstall" in err.lower()
+
+
+def test_a_broken_install_leaves_no_vault_behind(monkeypatch, tmp_path):
+    """The check runs before the passphrase prompt and before any write, so a
+    failed init cannot leave a half-made vault that `init` then refuses to
+    overwrite."""
+    monkeypatch.setattr(cli, "_data_dir", lambda: tmp_path / "not-here")
+    path = tmp_path / "v.vault"
+    args = _init_args(str(path))
+    with pytest.raises(SystemExit):
+        cli.cmd_init(args)
+    assert not path.exists()
+
+
+def test_the_shipped_install_finds_its_seed():
+    blobs = cli._seed_blobs()
+    assert [n for n, _ in blobs] == ["starter"]
+    assert len(blobs[0][1]) > 1_000_000
+
+
+def _init_args(path):
+    class A:
+        vault = None
+        passphrase = PASS
+        creator = "test"
+        keychain = False
+        no_app = True
+        keyfile = None
+    a = A()
+    a.vault = path
+    return a
+
+
+# ------------------------------------------------------------- the reporting
+
+@pytest.fixture(scope="module")
+def _own_seeded(tmp_path_factory):
+    """This module's own vault. The shared session fixture is written to by
+    other tests, and these assertions are about exactly which records come
+    back."""
+    p = str(tmp_path_factory.mktemp("starter-vis") / "v.vault")
+    v = Vault.create(p, PASS, creator="test")
+    packs.seed_records(v, (DATA / "starter.mpack").read_bytes(), caller="test")
+    return v
+
+
+@pytest.fixture()
+def sv(_own_seeded):
+    """Settings are per-vault and this one is reused, so put the toggle back."""
+    _own_seeded.config.settings["search_starter_facts"] = True
+    yield _own_seeded
+    _own_seeded.config.settings["search_starter_facts"] = True
+
+
+def test_the_recent_feed_hides_seeded_memories(sv):
+    """Unchanged behaviour, stated so the fix below cannot be read as a
+    licence to bury real memories under thousands of starting ones."""
+    out = sv.recent(caller="test", limit=5)
+    assert not any(r["seeded"] for r in out["results"])
+    assert out["counts"]["seeded"] == 6665
+
+
+def test_the_panel_says_the_starting_memories_are_there():
+    note = menubar.starter_note({"records": 6665, "organic": 0})
+    assert "6,665" in note and "searchable" in note
+    assert "nothing stored yet" != note
+
+
+def test_the_panel_still_says_empty_when_it_really_is_empty():
+    assert menubar.starter_note({"records": 0, "organic": 0}) == \
+        "nothing stored yet"
+
+
+def test_the_panel_counts_only_the_seeded_ones():
+    note = menubar.starter_note({"records": 6670, "organic": 5})
+    assert "6,665" in note
+
+
+def test_the_tray_and_the_menu_bar_say_the_same_thing():
+    from compartment import systray
+    state = {"vault": "/v", "exists": True, "locked": False,
+             "records": 6665, "organic": 0, "recent": [], "error": None,
+             "settings": {"capture_hook": False, "search_starter_facts": True,
+                          "auto_lock_minutes": 30}}
+    rows = systray.panel_rows(state)
+    empty = [text for kind, text in rows if kind == "empty"]
+    assert empty and "6,665" in empty[0]
+
+
+# ---------------------------------------------------------------- the toggle
+
+def test_search_returns_starting_memories_by_default(sv):
+    hits = sv.search("capital of France", caller="test", top_k=3)
+    assert any("Paris" in h["text"] for h in hits["results"])
+
+
+def test_turning_starter_facts_off_removes_them_from_search(sv):
+    on = sv.search("capital of France", caller="test", top_k=5)["results"]
+    assert any("Paris" in h["text"] for h in on)      # the toggle is what changed
+    sv.config.settings["search_starter_facts"] = False
+    off = sv.search("capital of France", caller="test", top_k=5)["results"]
+    assert not any("Paris" in h["text"] for h in off)
+    assert not any(is_seeded(json.dumps(h["tags"])) for h in off)
+
+
+def test_turning_starter_facts_off_keeps_what_the_agent_stored(sv):
+    sv.store("Max prefers the master-detail layout", caller="test")
+    sv.config.settings["search_starter_facts"] = False
+    hits = sv.search("master-detail layout preference", caller="test", top_k=5)
+    texts = [h["text"] for h in hits["results"]]
+    assert "Max prefers the master-detail layout" in texts
+    assert not any(is_seeded(json.dumps(h["tags"])) for h in hits["results"])
+
+
+def test_the_toggle_writes_the_setting_it_claims_to(tmp_path):
+    """It used to write include_packs_in_search, which stopped meaning
+    anything when the starting memories moved into "main"."""
+    path = str(tmp_path / "v.vault")
+    Vault.create(path, PASS, creator="t").lock()
+    menubar.set_setting(path, "search_starter_facts", False)
+    cfg = VaultConfig.load(path)
+    assert cfg.settings["search_starter_facts"] is False
+    assert cfg.settings.get("include_packs_in_search", True) is True
+
+
+def test_the_toggle_reads_back_what_it_wrote(tmp_path):
+    path = str(tmp_path / "v.vault")
+    Vault.create(path, PASS, creator="t").lock()
+    menubar.set_setting(path, "search_starter_facts", False)
+    assert menubar.read_settings(path)["search_starter_facts"] is False
+    menubar.set_setting(path, "search_starter_facts", True)
+    assert menubar.read_settings(path)["search_starter_facts"] is True
+
+
+def test_installed_packs_keep_their_own_switch(tmp_path):
+    """Two different things, two different settings: the starter toggle must
+    not silently change what installed packs do."""
+    path = str(tmp_path / "v.vault")
+    Vault.create(path, PASS, creator="t").lock()
+    cfg = VaultConfig.load(path)
+    cfg.settings["include_packs_in_search"] = False
+    cfg.save(path)
+    menubar.set_setting(path, "search_starter_facts", True)
+    assert VaultConfig.load(path).settings["include_packs_in_search"] is False
+
+
+# ------------------------------------------------------------------ the mark
+
+def test_seeded_records_are_marked_by_their_id_tag(vault):
+    packs.seed_records(vault, (DATA / "starter.mpack").read_bytes(), caller="t")
+    row = vault.db.conn.execute(
+        "SELECT tags FROM records LIMIT 1").fetchone()
+    assert is_seeded(row["tags"])
+
+
+def test_what_the_agent_stores_is_not_marked_seeded(vault):
+    vault.store("something learned during use", caller="t")
+    row = vault.db.conn.execute(
+        "SELECT tags FROM records ORDER BY ikey DESC LIMIT 1").fetchone()
+    assert not is_seeded(row["tags"])
+    assert json.loads(row["tags"]) == []