compartment 3.2__tar.gz → 3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compartment
-Version: 3.2
+Version: 3.4
 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
@@ -243,6 +243,11 @@ network at all.
 One command per platform. Each installs the package, creates your
 encrypted vault, and wires the agent.
 
+Every one of these is also a button in the app. Click the Compartment icon
+in your menu bar or notification area, and under **CONNECT AN AGENT** press
+Claude, Hermes or OpenClaw. The button runs the same `compartment integrate`
+command for you, so nobody has to open a terminal a second time.
+
 **Claude (Code + Desktop)** - macOS / Linux:
 ```bash
 pip install compartment && compartment init && compartment integrate claude

{compartment-3.2 → compartment-3.4}/README.md

@@ -197,6 +197,11 @@ network at all.
 One command per platform. Each installs the package, creates your
 encrypted vault, and wires the agent.
 
+Every one of these is also a button in the app. Click the Compartment icon
+in your menu bar or notification area, and under **CONNECT AN AGENT** press
+Claude, Hermes or OpenClaw. The button runs the same `compartment integrate`
+command for you, so nobody has to open a terminal a second time.
+
 **Claude (Code + Desktop)** - macOS / Linux:
 ```bash
 pip install compartment && compartment init && compartment integrate claude

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compartment"
-version = "3.2"
+version = "3.4"
 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.4}/src/compartment/__init__.py

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

{compartment-3.2 → compartment-3.4}/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.4}/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.4}/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:
@@ -279,6 +279,40 @@ def change_passphrase(vault: str, new: str, repeat: str) -> tuple[bool, str]:
     return False, (out[:120] or "could not change the passphrase")
 
 
+#: The agents `compartment integrate` can wire, in the order they are offered.
+#: Kept here rather than in the UI so the menu bar and the tray cannot drift
+#: apart, and so adding a target is one edit.
+INTEGRATION_TARGETS = (("claude", "Claude"),
+                       ("hermes", "Hermes"),
+                       ("openclaw", "OpenClaw"))
+
+
+def integrate(vault: str, target: str) -> tuple[bool, str]:
+    """Connect an agent to this vault, from the panel. Returns (ok, message).
+
+    The same command the README gives, run for you. It is offered here
+    because the terminal step after installing is where people stop: the
+    vault exists, the icon is in the menu bar, and nothing is using it yet
+    because nobody knew there was a second command.
+
+    Wiring an agent edits that agent's own configuration, so this reports
+    what happened rather than assuming - a Claude Code CLI that is not
+    installed is a normal outcome, not an error to hide.
+    """
+    if target not in dict(INTEGRATION_TARGETS):
+        return False, f"unknown target {target!r}"
+    code, out = _run([*_cli_argv(), "--vault", vault, "integrate", target],
+                     timeout=300)
+    text = " ".join(out.split())
+    if code != 0:
+        return False, (text[:200] or f"could not connect {target}")
+    name = dict(INTEGRATION_TARGETS)[target]
+    if "not found" in text.lower():
+        return True, (f"{name} is not installed on this machine yet. "
+                      "Compartment is ready for it when it is.")
+    return True, f"{name} is connected. Restart it to pick up the change."
+
+
 def summarise(state: dict) -> str:
     """One line under the title. Also what --self-check prints."""
     if not state["exists"]:
@@ -289,6 +323,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"
 
@@ -579,6 +626,7 @@ def run(vault: str | None = None, show: bool = False,
             self.pw_new = None
             self.pw_repeat = None
             self.change_note = None
+            self.connect_note = None  # what the last Connect button reported
             return self
 
         # ---- building the popover contents -----------------------------
@@ -724,13 +772,35 @@ def run(vault: str | None = None, show: bool = False,
                                10, secondary=True))
             views.append(divider())
 
+            # Installing leaves you with a vault and an icon, and nothing
+            # using either until an agent is wired to it. That step is one
+            # terminal command, which is one command too many for most
+            # people, so it is a button.
+            views.append(label("CONNECT AN AGENT", 10, bold=True,
+                               secondary=True))
+            connect_buttons = []
+            for i, (_target, name) in enumerate(INTEGRATION_TARGETS):
+                b = NSButton.buttonWithTitle_target_action_(
+                    name, self, "connectAgent:")
+                b.setTag_(i)
+                connect_buttons.append(b)
+            views.append(row(*connect_buttons, _spacer()))
+            views.append(label(
+                self.connect_note or
+                "Registers memory with the agent, writes its instructions "
+                "and turns on capture. The same as running `compartment "
+                "integrate claude` in a terminal.", 10, secondary=True,
+                wrap=True))
+            views.append(divider())
+
             views.append(label(f"LAST {RECENT_COUNT} MEMORIES", 10, bold=True,
                                secondary=True))
             if st["locked"]:
                 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())
@@ -857,6 +927,15 @@ def run(vault: str | None = None, show: bool = False,
             set_setting(vault_path, "auto_lock_minutes", AUTO_LOCK_CHOICES[idx])
             self.rebuild()
 
+        def connectAgent_(self, sender):
+            try:
+                target = INTEGRATION_TARGETS[int(sender.tag())][0]
+            except (IndexError, ValueError):
+                return
+            _ok, msg = integrate(vault_path, target)
+            self.connect_note = msg
+            self.rebuild()
+
         def refresh_(self, sender):
             self.rebuild()
 

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

@@ -29,10 +29,11 @@ from pathlib import Path
 
 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)
+from .menubar import (AUTO_LOCK_CHOICES, INTEGRATION_TARGETS, RECENT_COUNT,
+                      auto_lock_label, change_passphrase, claim_first_run,
+                      default_vault, fetch_state, integrate, lock_vault,
+                      self_check, set_setting, starter_note, summarise,
+                      unlock_vault)
 
 PANEL_WIDTH = 360
 PANEL_MAX_HEIGHT = 640
@@ -106,10 +107,20 @@ def panel_rows(state: dict) -> list[tuple[str, str]]:
                  f"{'on' if s['search_starter_facts'] else 'off'}"))
     rows.append(("choice:auto_lock_minutes",
                  f"Auto-lock: {auto_lock_label(s['auto_lock_minutes'])}"))
+    # Installing leaves you with a vault that nothing is using until an agent
+    # is wired to it. One button per agent, so that step is not a terminal
+    # command someone has to know about.
+    rows.append(("heading", "CONNECT AN AGENT"))
+    for target, name in INTEGRATION_TARGETS:
+        rows.append((f"connect:{target}", name))
+    rows.append(("note", state.get("connect_note") or
+                 "Registers memory with the agent, writes its instructions "
+                 "and turns on capture. The same as running "
+                 "`compartment integrate claude` in a terminal."))
     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
@@ -335,13 +346,36 @@ def run(vault: str | None = None, show: bool = False,
                        *[auto_lock_label(m) for m in AUTO_LOCK_CHOICES],
                        command=set_lock).pack(side="right")
 
+        ttk.Separator(frame).pack(fill="x", pady=10)
+        ttk.Label(frame, text="CONNECT AN AGENT",
+                  font=("Segoe UI", 8, "bold")).pack(anchor="w")
+
+        def connect(target):
+            _ok, note = integrate(vault_path, target)
+            panel["connect_note"] = note
+            refresh()
+
+        connect_row = ttk.Frame(frame)
+        connect_row.pack(fill="x", pady=(6, 0))
+        for _target, _name in INTEGRATION_TARGETS:
+            ttk.Button(connect_row, text=_name,
+                       command=lambda t=_target: connect(t)
+                       ).pack(side="left", padx=(0, 6))
+        ttk.Label(frame, text=panel.get("connect_note") or
+                  "Registers memory with the agent, writes its instructions "
+                  "and turns on capture. The same as running "
+                  "`compartment integrate claude` in a terminal.",
+                  foreground="#666", wraplength=WRAP,
+                  justify="left").pack(anchor="w", pady=(4, 0))
+
         ttk.Separator(frame).pack(fill="x", pady=10)
         ttk.Label(frame, text=f"LAST {RECENT_COUNT} MEMORIES",
                   font=("Segoe UI", 8, "bold")).pack(anchor="w")
         recent = state.get("recent") or []
         if not recent:
-            ttk.Label(frame, text="Nothing yet.",
-                      foreground="#666").pack(anchor="w", pady=(4, 0))
+            ttk.Label(frame, text=starter_note(state), foreground="#666",
+                      wraplength=WRAP,
+                      justify="left").pack(anchor="w", pady=(4, 0))
         for r in recent:
             ttk.Label(frame, text=(r.get("text") or "").strip(),
                       wraplength=WRAP,

{compartment-3.2 → compartment-3.4}/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.4}/src/compartment.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compartment
-Version: 3.2
+Version: 3.4
 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
@@ -243,6 +243,11 @@ network at all.
 One command per platform. Each installs the package, creates your
 encrypted vault, and wires the agent.
 
+Every one of these is also a button in the app. Click the Compartment icon
+in your menu bar or notification area, and under **CONNECT AN AGENT** press
+Claude, Hermes or OpenClaw. The button runs the same `compartment integrate`
+command for you, so nobody has to open a terminal a second time.
+
 **Claude (Code + Desktop)** - macOS / Linux:
 ```bash
 pip install compartment && compartment init && compartment integrate claude

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

@@ -46,6 +46,7 @@ tests/test_attempt_pacing.py
 tests/test_audit_chain.py
 tests/test_claude_hooks_and_integrate.py
 tests/test_claude_memory_and_recent.py
+tests/test_connect_buttons.py
 tests/test_crypto.py
 tests/test_dash.py
 tests/test_instructions.py
@@ -63,6 +64,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.4/tests/test_connect_buttons.py

@@ -0,0 +1,165 @@
+"""Connecting an agent is a button, on both platforms.
+
+`compartment integrate <agent>` is the step people miss: the vault exists,
+the icon is in the menu bar, and nothing is using either because the second
+command was never run. The panel offers it directly, and these tests hold the
+two front ends to the same list of agents as the CLI.
+"""
+import re
+
+import pytest
+
+from compartment import cli, menubar, systray
+
+
+def _state(**over):
+    st = {"vault": "/v", "exists": True, "locked": False, "records": 6665,
+          "organic": 0, "recent": [], "error": None,
+          "settings": {"capture_hook": True, "search_starter_facts": True,
+                       "auto_lock_minutes": 30}}
+    st.update(over)
+    return st
+
+
+# ------------------------------------------------------------- the agent list
+
+@pytest.mark.parametrize("target,_name", menubar.INTEGRATION_TARGETS)
+def test_every_button_names_a_target_the_cli_accepts(monkeypatch, target,
+                                                     _name):
+    """A button for an agent the CLI rejects is a button that cannot work.
+    Goes through the real parser, which is the only thing that can say."""
+    seen = {}
+    monkeypatch.setattr(cli, "cmd_integrate",
+                        lambda args: seen.update(vars(args)))
+    cli.main(["integrate", target])
+    assert seen["target"] == target
+
+
+def test_no_agent_the_cli_accepts_is_missing_a_button(monkeypatch, capsys):
+    """The other direction: adding a target to the CLI and forgetting the
+    button leaves an agent nobody can reach from the app. argparse names
+    every choice it accepts when it rejects one, so ask it."""
+    monkeypatch.setattr(cli, "cmd_integrate", lambda args: None)
+    with pytest.raises(SystemExit):
+        cli.main(["integrate", "no-such-agent"])
+    err = capsys.readouterr().err
+    choices = set(re.findall(r"'([a-z]+)'", err.split("choose from")[-1]))
+    assert choices == {t for t, _ in menubar.INTEGRATION_TARGETS}
+
+
+def test_the_agents_are_offered_in_a_fixed_order():
+    assert [t for t, _ in menubar.INTEGRATION_TARGETS] == \
+        ["claude", "hermes", "openclaw"]
+
+
+def test_every_agent_has_a_display_name():
+    for target, name in menubar.INTEGRATION_TARGETS:
+        assert name and name.lower().replace(" ", "") == target
+
+
+# ---------------------------------------------------------------- the action
+
+def test_an_unknown_target_never_runs_anything(monkeypatch):
+    called = []
+    monkeypatch.setattr(menubar, "_run", lambda *a, **k: called.append(a))
+    ok, msg = menubar.integrate("/v", "notanagent")
+    assert ok is False and "notanagent" in msg
+    assert called == []
+
+
+def test_it_runs_the_documented_command(monkeypatch):
+    seen = {}
+
+    def fake_run(args, timeout=60):
+        seen["args"] = args
+        return 0, "registered."
+    monkeypatch.setattr(menubar, "_run", fake_run)
+    ok, _ = menubar.integrate("/path/to/v.vault", "claude")
+    assert ok is True
+    assert seen["args"][-3:] == ["v.vault", "integrate", "claude"] or \
+        seen["args"][-2:] == ["integrate", "claude"]
+    assert "--vault" in seen["args"]
+    assert "/path/to/v.vault" in seen["args"]
+
+
+def test_success_tells_the_user_to_restart_the_agent(monkeypatch):
+    monkeypatch.setattr(menubar, "_run", lambda *a, **k: (0, "registered."))
+    ok, msg = menubar.integrate("/v", "claude")
+    assert ok is True
+    assert "Claude" in msg and "estart" in msg
+
+
+def test_a_missing_agent_is_reported_as_normal_not_as_failure(monkeypatch):
+    """Not having Hermes installed is not an error, and must not read as
+    one: the wiring that can be done is still done."""
+    monkeypatch.setattr(menubar, "_run",
+                        lambda *a, **k: (0, "hermes not found; finish with…"))
+    ok, msg = menubar.integrate("/v", "hermes")
+    assert ok is True
+    assert "not installed" in msg
+
+
+def test_a_real_failure_surfaces_its_reason(monkeypatch):
+    monkeypatch.setattr(menubar, "_run",
+                        lambda *a, **k: (1, "permission denied writing config"))
+    ok, msg = menubar.integrate("/v", "claude")
+    assert ok is False
+    assert "permission denied" in msg
+
+
+def test_a_failure_with_no_output_still_says_something(monkeypatch):
+    monkeypatch.setattr(menubar, "_run", lambda *a, **k: (1, ""))
+    ok, msg = menubar.integrate("/v", "openclaw")
+    assert ok is False and msg
+
+
+def test_wiring_gets_a_longer_leash_than_a_status_call(monkeypatch):
+    """Installing into the Hermes venv can take a while; a 60 s default would
+    time out mid-pip and leave the agent half-wired."""
+    seen = {}
+
+    def fake_run(args, timeout=60):
+        seen["timeout"] = timeout
+        return 0, "ok"
+    monkeypatch.setattr(menubar, "_run", fake_run)
+    menubar.integrate("/v", "hermes")
+    assert seen["timeout"] >= 300
+
+
+# ----------------------------------------------------------------- the panel
+
+def test_the_tray_panel_has_a_button_per_agent():
+    rows = systray.panel_rows(_state())
+    connects = [text for kind, text in rows if kind.startswith("connect:")]
+    assert connects == ["Claude", "Hermes", "OpenClaw"]
+
+
+def test_the_tray_panel_heads_the_section():
+    rows = systray.panel_rows(_state())
+    assert ("heading", "CONNECT AN AGENT") in rows
+
+
+def test_the_tray_panel_explains_what_the_buttons_do():
+    rows = systray.panel_rows(_state())
+    note = [t for k, t in rows if k == "note"][0]
+    assert "integrate claude" in note
+
+
+def test_the_tray_panel_shows_the_last_result_once_there_is_one():
+    rows = systray.panel_rows(_state(connect_note="Claude is connected."))
+    note = [t for k, t in rows if k == "note"][0]
+    assert note == "Claude is connected."
+
+
+def test_the_buttons_are_offered_even_while_the_vault_is_locked():
+    """Wiring an agent edits the agent's config, not the vault, so a locked
+    vault is no reason to hide it."""
+    rows = systray.panel_rows(_state(locked=True))
+    assert [t for k, t in rows if k.startswith("connect:")] == \
+        ["Claude", "Hermes", "OpenClaw"]
+
+
+@pytest.mark.parametrize("target,name", menubar.INTEGRATION_TARGETS)
+def test_each_row_carries_the_target_the_action_needs(target, name):
+    rows = systray.panel_rows(_state())
+    assert (f"connect:{target}", name) in rows

{compartment-3.2 → compartment-3.4}/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.4/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"]) == []

{compartment-3.2 → compartment-3.4}/tests/test_systray.py

@@ -91,7 +91,8 @@ def test_missing_vault_and_errors_are_shown_not_raised():
 def test_settings_toggles_are_exactly_the_three_the_mac_panel_has():
     from compartment import menubar
     rows = systray.panel_rows(_state())
-    keys = {k.split(":", 1)[1] for k, _ in rows if ":" in k}
+    keys = {k.split(":", 1)[1] for k, _ in rows
+            if k.startswith(("toggle:", "choice:"))}
     assert keys == set(menubar.fetch_state("/does/not/exist")["settings"])