switchroom 0.16.46 → 0.17.0

package/vendor/hindsight-memory/scripts/lib/config.py

@@ -40,6 +40,12 @@ DEFAULTS = {
     "recallContextTurns": 1,
     "recallMaxQueryChars": 800,
     "recallRoles": ["user", "assistant"],
+    # Upstream 962140eef — optional recall tag filters passed through to the
+    # recall API, plus per-additional-bank overrides keyed by bank ID.
+    "recallTags": [],
+    "recallTagsMatch": "any",
+    "recallTagGroups": None,
+    "recallAdditionalBankFilters": {},
     "recallPromptPreamble": (
         "Relevant memories from past conversations (prioritize recent when "
         "conflicting). Only use memories that are directly useful to continue "
@@ -63,6 +69,12 @@ DEFAULTS = {
     "daemonIdleTimeout": 0,
     "embedVersion": "latest",
     "embedPackagePath": None,
+    # Upstream 55ef70679 — optional global HTTP request timeout override
+    # (seconds). None = keep each call's own default. NOTE: switchroom's
+    # recall.py deliberately does NOT wire this override into its client —
+    # recall carries its own 8s hook-budget timeout (see recall.py). This
+    # mainly benefits retain's 15s timeout on slow/loaded servers.
+    "requestTimeoutSeconds": None,
     # Bank
     "bankId": None,
     "bankIdPrefix": "",
@@ -109,8 +121,16 @@ ENV_OVERRIDES = {
     "HINDSIGHT_RECALL_SKIP_TRIVIAL": ("recallSkipTrivial", bool),
     "HINDSIGHT_RECALL_MAX_QUERY_CHARS": ("recallMaxQueryChars", int),
     "HINDSIGHT_RECALL_CONTEXT_TURNS": ("recallContextTurns", int),
+    # Upstream 962140eef — recall tag filters. The tags env var accepts JSON
+    # or a comma-separated list; the others must be JSON.
+    "HINDSIGHT_RECALL_TAGS": ("recallTags", list),
+    "HINDSIGHT_RECALL_TAGS_MATCH": ("recallTagsMatch", str),
+    "HINDSIGHT_RECALL_TAG_GROUPS": ("recallTagGroups", dict),
+    "HINDSIGHT_RECALL_ADDITIONAL_BANK_FILTERS": ("recallAdditionalBankFilters", dict),
     "HINDSIGHT_API_PORT": ("apiPort", int),
     "HINDSIGHT_DAEMON_IDLE_TIMEOUT": ("daemonIdleTimeout", int),
+    # Upstream 55ef70679 — global request timeout override.
+    "HINDSIGHT_REQUEST_TIMEOUT_SECONDS": ("requestTimeoutSeconds", int),
     "HINDSIGHT_EMBED_VERSION": ("embedVersion", str),
     "HINDSIGHT_EMBED_PACKAGE_PATH": ("embedPackagePath", str),
     "HINDSIGHT_DYNAMIC_BANK_ID": ("dynamicBankId", bool),
@@ -131,8 +151,27 @@ def _cast_env(value: str, typ):
         if typ is float:
             return float(value)
         if typ is list:
-            # Comma-separated → list of trimmed, non-empty strings.
-            return [t.strip() for t in value.split(",") if t.strip()]
+            # JSON list first (upstream 962140eef). A value that parses as
+            # JSON but is NOT a list (e.g. `42`, `"x"`, `{}`) is a config
+            # mistake, not a comma-separated string — return None so the
+            # default is kept (matches upstream; fail-open). Only values
+            # that don't parse as JSON at all take the comma-split path.
+            try:
+                parsed = json.loads(value)
+            except ValueError:
+                if value.lstrip().startswith(("[", "{")):
+                    # Looks like intended JSON but doesn't parse —
+                    # malformed config, not a comma list. Keep default.
+                    return None
+                # Comma-separated → list of trimmed, non-empty strings.
+                return [t.strip() for t in value.split(",") if t.strip()]
+            return parsed if isinstance(parsed, list) else None
+        if typ is dict:
+            # JSON only (dict or list accepted — tag_groups may be a list).
+            parsed = json.loads(value)
+            if isinstance(parsed, (dict, list)):
+                return parsed
+            return None
         return value
     except (ValueError, AttributeError):
         return None

package/vendor/hindsight-memory/scripts/lib/content.py

@@ -221,10 +221,13 @@ def format_memories(results: list) -> str:
 def format_current_time() -> str:
     """Format current UTC time for recall context.
 
+    The "UTC" suffix is explicit so client LLMs do not misread the
+    value as local time when reasoning about wall-clock context.
+
     Port of: formatCurrentTimeForRecall() in index.js
     """
     now = datetime.now(timezone.utc)
-    return now.strftime("%Y-%m-%d %H:%M")
+    return now.strftime("%Y-%m-%d %H:%M UTC")
 
 
 # ---------------------------------------------------------------------------

package/vendor/hindsight-memory/scripts/lib/daemon.py

@@ -71,8 +71,17 @@ def _is_embed_available(config: dict) -> bool:
     return shutil.which("uvx") is not None or shutil.which("hindsight-embed") is not None
 
 
-def _check_health(base_url: str, timeout: int = 2) -> bool:
-    """Quick health check against a Hindsight server."""
+def _check_health(base_url: str, timeout: int = 10) -> bool:
+    """Quick health check against a Hindsight server.
+
+    Default timeout is 10s (matching the recall hook budget): under load an
+    alive-but-busy daemon mid fact-extraction may not answer /health within a
+    couple of seconds. A too-short timeout yields a false negative, so
+    get_api_url() falls through to _ensure_daemon_running() ->
+    `hindsight-embed daemon start`, whose _clear_port() then SIGTERMs the
+    live daemon -- a restart/kill loop. A 10s budget lets a busy daemon
+    respond before it is declared dead.
+    """
     try:
         url = f"{base_url.rstrip('/')}/health"
         req = urllib.request.Request(url, method="GET", headers={"User-Agent": USER_AGENT})

package/vendor/hindsight-memory/scripts/recall.py

@@ -229,6 +229,33 @@ def _resolve_sender_bank(
     return additional_banks
 
 
+def _tag_filter_sig(
+    recall_tags,
+    tags_match,
+    tag_groups,
+    additional_bank_filters,
+) -> str:
+    """Stable fingerprint of the recall tag-filter configuration
+    (upstream 962140eef) for cache keying. Tag filters change what the
+    recall API returns for an identical query, so they MUST be part of
+    the cache key — otherwise a config change (or per-bank filter edit)
+    within the TTL window would serve stale, differently-filtered
+    results. Empty/default filters collapse to "" so pre-existing cache
+    behaviour (and keys) are unchanged when the feature is unused."""
+    if not (recall_tags or tag_groups or additional_bank_filters):
+        return ""
+    try:
+        return json.dumps(
+            [recall_tags, tags_match, tag_groups, additional_bank_filters],
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+    except (TypeError, ValueError):
+        # Unserializable config — fall back to repr; stable within a
+        # process and still distinguishes filtered from unfiltered.
+        return repr([recall_tags, tags_match, tag_groups, additional_bank_filters])
+
+
 def _cache_key(
     session_id: str,
     prompt: str,
@@ -236,6 +263,7 @@ def _cache_key(
     extra_banks: list,
     active_thread_id: str | None = None,
     active_sender: str | None = None,
+    tag_filter_sig: str = "",
 ) -> str:
     """Stable hash for cache keying. Session_id is included so a new
     session always misses, regardless of the TTL setting. Extra banks
@@ -259,6 +287,9 @@ def _cache_key(
         ",".join(sorted(extra_banks or [])),
         active_thread_id or "",
         active_sender or "",
+        # Upstream 962140eef port: tag filters shape the result set, so
+        # they are part of the key (see _tag_filter_sig). "" when unused.
+        tag_filter_sig or "",
     ]
     payload = "\x1f".join(parts)
     return hashlib.sha256(payload.encode("utf-8")).hexdigest()
@@ -703,11 +734,32 @@ def main():
         additional_banks,
     )
 
+    # Upstream 962140eef — optional recall tag filters. Resolved BEFORE the
+    # cache check so the tag-filter fingerprint is part of the cache key
+    # (filters change the result set for an identical query). Per-bank
+    # overrides in recallAdditionalBankFilters apply to any additional bank —
+    # including sender banks appended by _resolve_sender_bank above.
+    recall_tags = config.get("recallTags") or None
+    tag_groups = config.get("recallTagGroups") or None
+    tags_match = config.get("recallTagsMatch") if recall_tags or tag_groups else None
+    additional_bank_filters = config.get("recallAdditionalBankFilters") or {}
+    if not isinstance(additional_bank_filters, dict):
+        additional_bank_filters = {}
+    tag_filter_sig = _tag_filter_sig(recall_tags, tags_match, tag_groups, additional_bank_filters)
+
     # Switchroom #424 phase 4.1 — cache check BEFORE any HTTP traffic.
     # Whole-session-scoped, opt-in via HINDSIGHT_RECALL_CACHE_TTL_SECS.
     cache_ttl = _cache_ttl_secs()
     cache_key = (
-        _cache_key(session_id, prompt, bank_id, additional_banks, active_thread_id, active_sender)
+        _cache_key(
+            session_id,
+            prompt,
+            bank_id,
+            additional_banks,
+            active_thread_id,
+            active_sender,
+            tag_filter_sig,
+        )
         if cache_ttl > 0
         else ""
     )
@@ -787,6 +839,11 @@ def main():
             max_tokens=config.get("recallMaxTokens", 1024),
             budget=config.get("recallBudget", "mid"),
             types=config.get("recallTypes"),
+            # Upstream 962140eef — optional tag filters (resolved above the
+            # cache check; part of the cache key).
+            tags=recall_tags,
+            tags_match=tags_match,
+            tag_groups=tag_groups,
             # 8s in-script timeout leaves 4s headroom inside the 12s
             # UserPromptSubmit hook ceiling (see hooks.json:20) for cache
             # write + block formatting. Tightened from 10s in switchroom
@@ -809,6 +866,19 @@ def main():
     # cache key reflects every bank queried; reuse that local instead of
     # re-reading config.
     for extra_bank_id in additional_banks:
+        # Upstream 962140eef — per-bank tag-filter overrides; fall back to
+        # the global filters when the bank has no entry. Applies uniformly
+        # to config-listed banks and sender banks appended by
+        # _resolve_sender_bank (both flow through `additional_banks`).
+        extra_filter = additional_bank_filters.get(extra_bank_id, {})
+        if not isinstance(extra_filter, dict):
+            extra_filter = {}
+        extra_tags = extra_filter.get("recallTags", recall_tags) or None
+        extra_tag_groups = extra_filter.get("recallTagGroups", tag_groups) or None
+        extra_tags_match = extra_filter.get(
+            "recallTagsMatch",
+            tags_match if extra_tags or extra_tag_groups else None,
+        )
         try:
             extra_response = client.recall(
                 bank_id=extra_bank_id,
@@ -816,6 +886,9 @@ def main():
                 max_tokens=config.get("recallMaxTokens", 1024),
                 budget=config.get("recallBudget", "mid"),
                 types=config.get("recallTypes"),
+                tags=extra_tags,
+                tags_match=extra_tags_match,
+                tag_groups=extra_tag_groups,
                 # 8s in-script timeout leaves 4s headroom inside the 12s
                 # UserPromptSubmit hook ceiling (see hooks.json:20) for cache
                 # write + block formatting. Tightened from 10s in switchroom

package/vendor/hindsight-memory/scripts/retain.py

@@ -156,7 +156,14 @@ def run_retain(hook_input: dict, force: bool = False) -> dict:
 
     api_token = config.get("hindsightApiToken")
     try:
-        client = HindsightClient(api_url, api_token)
+        # Upstream 55ef70679 — honor the optional requestTimeoutSeconds
+        # override (retain runs outside the recall hook budget, so a longer
+        # timeout is safe here; recall.py deliberately omits this).
+        client = HindsightClient(
+            api_url,
+            api_token,
+            request_timeout_override=config.get("requestTimeoutSeconds"),
+        )
     except ValueError as e:
         print(f"[Hindsight] Invalid API URL: {e}", file=sys.stderr)
         return {"status": "failed", "error": e, "payload": None}

package/vendor/hindsight-memory/scripts/tests/test_config_client_casts.py

@@ -0,0 +1,111 @@
+"""Unit tests for config env casting (`lib.config._cast_env`) and the
+client's request-timeout override clamp (`HindsightClient._resolve_timeout`).
+
+Follow-ups from the #2816 review punch list:
+  - list cast: a value that parses as JSON but is NOT a list (e.g. `42`)
+    must return None (keep default, fail-open) instead of falling through
+    to comma-split and producing a junk one-element list. Malformed
+    intended-JSON (`[1,2`) also keeps the default; plain comma strings
+    still split.
+  - timeout override: zero/negative env values are clamped to >= 1 instead
+    of passing straight through to urlopen.
+
+Stdlib-only.
+"""
+
+import os
+import sys
+import unittest
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+from lib.config import _cast_env  # noqa: E402
+from lib.client import HindsightClient  # noqa: E402
+
+
+class CastEnvListTests(unittest.TestCase):
+    def test_valid_json_list(self):
+        self.assertEqual(_cast_env('["a", "b"]', list), ["a", "b"])
+
+    def test_empty_json_list(self):
+        self.assertEqual(_cast_env("[]", list), [])
+
+    def test_comma_string_splits(self):
+        self.assertEqual(_cast_env("a, b ,c", list), ["a", "b", "c"])
+
+    def test_comma_string_drops_empty_tokens(self):
+        self.assertEqual(_cast_env("a,,b,", list), ["a", "b"])
+
+    def test_single_bare_string(self):
+        # Not valid JSON, no commas → one-element list.
+        self.assertEqual(_cast_env("solo", list), ["solo"])
+
+    def test_json_non_list_scalar_returns_none(self):
+        # Parses as JSON int — not a list, not a comma string. Default kept.
+        self.assertIsNone(_cast_env("42", list))
+
+    def test_json_non_list_object_returns_none(self):
+        self.assertIsNone(_cast_env('{"a": 1}', list))
+
+    def test_json_string_returns_none(self):
+        # A JSON-quoted string is valid JSON but not a list.
+        self.assertIsNone(_cast_env('"tag"', list))
+
+    def test_malformed_json_array_returns_none(self):
+        # Looks like intended JSON but doesn't parse → default kept,
+        # NOT comma-split into junk like ['["a"', '"b"'].
+        self.assertIsNone(_cast_env('["a", "b"', list))
+
+    def test_malformed_json_object_returns_none(self):
+        self.assertIsNone(_cast_env('{"a": ', list))
+
+
+class CastEnvOtherTypesTests(unittest.TestCase):
+    """Guard the neighbours the list change must not disturb."""
+
+    def test_int_valid(self):
+        self.assertEqual(_cast_env("30", int), 30)
+
+    def test_int_invalid_returns_none(self):
+        self.assertIsNone(_cast_env("thirty", int))
+
+    def test_bool_true_variants(self):
+        for v in ("true", "1", "yes", "TRUE"):
+            self.assertTrue(_cast_env(v, bool), v)
+
+    def test_bool_false(self):
+        self.assertFalse(_cast_env("false", bool))
+
+    def test_dict_valid(self):
+        self.assertEqual(_cast_env('{"a": 1}', dict), {"a": 1})
+
+    def test_dict_non_container_returns_none(self):
+        self.assertIsNone(_cast_env("42", dict))
+
+
+class ResolveTimeoutTests(unittest.TestCase):
+    URL = "http://127.0.0.1:9999"
+
+    def _client(self, override):
+        return HindsightClient(self.URL, request_timeout_override=override)
+
+    def test_no_override_uses_caller_timeout(self):
+        self.assertEqual(self._client(None)._resolve_timeout(30), 30)
+
+    def test_valid_override_wins(self):
+        self.assertEqual(self._client(15)._resolve_timeout(30), 15)
+
+    def test_zero_override_clamped_to_one(self):
+        self.assertEqual(self._client(0)._resolve_timeout(30), 1)
+
+    def test_negative_override_clamped_to_one(self):
+        self.assertEqual(self._client(-5)._resolve_timeout(30), 1)
+
+    def test_one_passes_through(self):
+        self.assertEqual(self._client(1)._resolve_timeout(30), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/scripts/tests/test_recall_integration.py

@@ -55,13 +55,35 @@ class _FakeClient:
         self._memories = memories if memories is not None else []
         self._recall_exc = recall_exc
         self._list_exc = list_exc
+        # One entry per recall() call — lets tests assert the tag-filter
+        # kwargs (upstream 962140eef) that main() passed per bank.
+        self.recall_calls = []
 
     def list_directives(self, bank_id, active_only=True, timeout=2):
         if self._list_exc is not None:
             raise self._list_exc
         return {"items": list(self._directives)}
 
-    def recall(self, bank_id, query, max_tokens=1024, budget="mid", types=None, timeout=10):
+    def recall(
+        self,
+        bank_id,
+        query,
+        max_tokens=1024,
+        budget="mid",
+        types=None,
+        tags=None,
+        tags_match=None,
+        tag_groups=None,
+        timeout=10,
+    ):
+        self.recall_calls.append(
+            {
+                "bank_id": bank_id,
+                "tags": tags,
+                "tags_match": tags_match,
+                "tag_groups": tag_groups,
+            }
+        )
         if self._recall_exc is not None:
             raise self._recall_exc
         return {"results": list(self._memories)}
@@ -617,5 +639,67 @@ class OverlapGateIntegrationTests(unittest.TestCase):
         self.assertIsNone(ctx)
 
 
+class RecallTagFilterIntegrationTests(unittest.TestCase):
+    """Upstream 962140eef port — tag filters flow through main() to each
+    per-bank recall call, composed with our additional-banks routing."""
+
+    def test_global_tags_passed_to_primary_bank(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(
+            client,
+            config_extra={
+                "recallTags": ["memory_type:rule"],
+                "recallTagsMatch": "any_strict",
+            },
+        )
+        self.assertEqual(client.recall_calls[0]["tags"], ["memory_type:rule"])
+        self.assertEqual(client.recall_calls[0]["tags_match"], "any_strict")
+
+    def test_no_tags_match_sent_without_tags_or_groups(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(client, config_extra={"recallTagsMatch": "all"})
+        self.assertIsNone(client.recall_calls[0]["tags"])
+        self.assertIsNone(client.recall_calls[0]["tags_match"])
+        self.assertIsNone(client.recall_calls[0]["tag_groups"])
+
+    def test_per_bank_filter_overrides_global_for_additional_bank(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallTags": ["tech_stack:supabase"],
+                "recallTagsMatch": "any",
+                "recallAdditionalBankFilters": {
+                    "shared-bank": {
+                        "recallTags": ["memory_type:rule"],
+                        "recallTagsMatch": "all_strict",
+                    }
+                },
+            },
+        )
+        primary, extra = client.recall_calls[0], client.recall_calls[1]
+        self.assertEqual(primary["bank_id"], "test-bank")
+        self.assertEqual(primary["tags"], ["tech_stack:supabase"])
+        self.assertEqual(primary["tags_match"], "any")
+        self.assertEqual(extra["bank_id"], "shared-bank")
+        self.assertEqual(extra["tags"], ["memory_type:rule"])
+        self.assertEqual(extra["tags_match"], "all_strict")
+
+    def test_additional_bank_without_override_inherits_global(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallTags": ["memory_type:rule"],
+            },
+        )
+        extra = client.recall_calls[1]
+        self.assertEqual(extra["tags"], ["memory_type:rule"])
+        # Global tags_match defaults are only sent when filters are active.
+        self.assertEqual(extra["tags_match"], None)
+
+
 if __name__ == "__main__":
     unittest.main()

package/vendor/hindsight-memory/scripts/tests/test_recall_tag_filters.py

@@ -0,0 +1,107 @@
+"""Unit tests for the recall tag-filter port (upstream 962140eef).
+
+Covers the switchroom-specific composition points that upstream's own tests
+cannot: the tag-filter fingerprint (`_tag_filter_sig`) and its inclusion in
+the recall cache key (`_cache_key`). Tag filters change what the recall API
+returns for an identical query, so a filter change within the cache TTL must
+produce a cache MISS — otherwise stale, differently-filtered results would
+be served.
+
+Stdlib-only.
+"""
+
+import os
+import sys
+import unittest
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+import recall  # noqa: E402
+
+
+class TagFilterSigTests(unittest.TestCase):
+    def test_empty_filters_collapse_to_empty_string(self):
+        # Backward-compat: unused feature must not perturb existing keys.
+        self.assertEqual(recall._tag_filter_sig(None, None, None, {}), "")
+        self.assertEqual(recall._tag_filter_sig([], None, None, {}), "")
+
+    def test_tags_produce_nonempty_sig(self):
+        self.assertNotEqual(recall._tag_filter_sig(["memory_type:rule"], "any", None, {}), "")
+
+    def test_tag_groups_alone_produce_nonempty_sig(self):
+        groups = [{"op": "all", "tags": ["a", "b"]}]
+        self.assertNotEqual(recall._tag_filter_sig(None, "any", groups, {}), "")
+
+    def test_bank_filters_alone_produce_nonempty_sig(self):
+        filters = {"profile-bank": {"recallTags": ["memory_type:rule"]}}
+        self.assertNotEqual(recall._tag_filter_sig(None, None, None, filters), "")
+
+    def test_sig_is_deterministic(self):
+        a = recall._tag_filter_sig(["t1"], "all", None, {"b": {"recallTags": ["x"]}})
+        b = recall._tag_filter_sig(["t1"], "all", None, {"b": {"recallTags": ["x"]}})
+        self.assertEqual(a, b)
+
+    def test_sig_stable_across_dict_key_order(self):
+        f1 = {"a": {"recallTags": ["x"]}, "b": {"recallTags": ["y"]}}
+        f2 = {"b": {"recallTags": ["y"]}, "a": {"recallTags": ["x"]}}
+        self.assertEqual(
+            recall._tag_filter_sig(["t"], "any", None, f1),
+            recall._tag_filter_sig(["t"], "any", None, f2),
+        )
+
+    def test_different_tags_different_sig(self):
+        self.assertNotEqual(
+            recall._tag_filter_sig(["memory_type:rule"], "any", None, {}),
+            recall._tag_filter_sig(["memory_type:fact"], "any", None, {}),
+        )
+
+    def test_different_match_mode_different_sig(self):
+        self.assertNotEqual(
+            recall._tag_filter_sig(["t"], "any", None, {}),
+            recall._tag_filter_sig(["t"], "all_strict", None, {}),
+        )
+
+    def test_unserializable_falls_back_to_repr(self):
+        # A pathological config value must not raise; it still yields a
+        # non-empty signature distinguishing it from "no filters".
+        sig = recall._tag_filter_sig([object()], "any", None, {})
+        self.assertTrue(sig)
+
+
+class CacheKeyTagFilterTests(unittest.TestCase):
+    """The tag-filter fingerprint must be part of the recall cache key."""
+
+    ARGS = ("s1", "what are the rules", "clerk", ["profile"], "42", "ken")
+
+    def test_no_filters_matches_legacy_key(self):
+        # Default arg == explicit "" — pre-feature cache keys are unchanged.
+        legacy = recall._cache_key(*self.ARGS)
+        explicit = recall._cache_key(*self.ARGS, "")
+        self.assertEqual(legacy, explicit)
+
+    def test_filters_change_the_key(self):
+        sig = recall._tag_filter_sig(["memory_type:rule"], "any", None, {})
+        self.assertNotEqual(recall._cache_key(*self.ARGS), recall._cache_key(*self.ARGS, sig))
+
+    def test_different_filters_different_keys(self):
+        sig_a = recall._tag_filter_sig(["memory_type:rule"], "any", None, {})
+        sig_b = recall._tag_filter_sig(["memory_type:fact"], "any", None, {})
+        self.assertNotEqual(recall._cache_key(*self.ARGS, sig_a), recall._cache_key(*self.ARGS, sig_b))
+
+    def test_per_bank_filter_change_changes_key(self):
+        # Editing only recallAdditionalBankFilters (e.g. for a sender bank)
+        # must also invalidate the cache.
+        sig_a = recall._tag_filter_sig(["t"], "any", None, {"profile": {"recallTags": ["x"]}})
+        sig_b = recall._tag_filter_sig(["t"], "any", None, {"profile": {"recallTags": ["y"]}})
+        self.assertNotEqual(recall._cache_key(*self.ARGS, sig_a), recall._cache_key(*self.ARGS, sig_b))
+
+    def test_same_filters_same_key(self):
+        sig1 = recall._tag_filter_sig(["t"], "all", None, {})
+        sig2 = recall._tag_filter_sig(["t"], "all", None, {})
+        self.assertEqual(recall._cache_key(*self.ARGS, sig1), recall._cache_key(*self.ARGS, sig2))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/settings.json

@@ -13,6 +13,10 @@
   "recallContextTurns": 1,
   "recallMaxQueryChars": 800,
   "recallRoles": ["user", "assistant"],
+  "recallTags": [],
+  "recallTagsMatch": "any",
+  "recallTagGroups": null,
+  "recallAdditionalBankFilters": {},
   "recallPromptPreamble": "Relevant memories from past conversations (prioritize recent when conflicting). Only use memories that are directly useful to continue this conversation; ignore the rest:",
   "retainRoles": ["user", "assistant"],
   "retainEveryNTurns": 10,