switchroom 0.20.21 → 0.21.0

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

@@ -565,6 +565,119 @@ class TestObservationScopes(DurabilityTestBase):
         self.assertTrue(all(s is None for s in self.daemon.observation_scopes_seen))
 
 
+class TestDrainAdvancesWatermark(DurabilityTestBase):
+    """switchroom #4571 — the drain must advance the transcript watermark for a
+    reconcile-sourced slice it confirms durable, so reconcile stops re-deriving
+    and re-enqueueing the identical tail on every boot (the recurring
+    ``pending-retains`` spike). And it must NOT advance while an earlier sibling
+    of the same session is still queued (the no-loss guard).
+    """
+
+    # -- the fix: an enqueued tail, once drained, advances the watermark --------
+    def test_enqueued_tail_drained_advances_watermark_and_stops_reenqueue(self):
+        # This test FAILS on HEAD: the drain never commits the watermark for an
+        # enqueued reconcile slice, so `watermark.load` stays None after the
+        # drain and the second reconcile re-enqueues the same tail.
+        session = "drainA"
+        tpath = os.path.join(self.transcripts, f"{session}.jsonl")
+        _write_transcript(tpath, 3, session_prefix=session)
+        hook = {"session_id": session, "transcript_path": tpath, "cwd": "/x"}
+
+        # Force the out-of-lookback ENQUEUE path (no inline POST): lookback=0
+        # makes every transcript "too old", so reconcile enqueues the full tail
+        # and defers it to the drain — exactly the path that never committed.
+        with mock.patch.dict(os.environ, {"HINDSIGHT_RECONCILE_LOOKBACK_H": "0"}):
+            s1 = reconcile_tail.reconcile(self._config(), hook_input=hook)
+        self.assertEqual(s1["enqueued"], 1)
+        self.assertEqual(len(self._pending_entries()), 1)
+        # Nothing posted inline, so the watermark is still unset.
+        self.assertIsNone(watermark.load(session))
+
+        # Drain against a healthy daemon: the tail lands durably AND (the fix)
+        # the watermark advances to the transcript tail.
+        from drain_pending import drain
+        drain(self._config())
+        self.assertEqual(len(self._pending_entries()), 0)
+        wm = watermark.load(session)
+        self.assertIsNotNone(
+            wm,
+            "drain must advance the watermark for a confirmed-durable reconcile "
+            "tail (#4571) — without it, reconcile re-enqueues every boot",
+        )
+        self.assertEqual(wm["last_uuid"], f"{session}-a2")
+
+        # Second reconcile pass (still out of lookback) is now skipped_clean:
+        # the tail is watermarked, so it is NOT re-derived or re-enqueued.
+        with mock.patch.dict(os.environ, {"HINDSIGHT_RECONCILE_LOOKBACK_H": "0"}):
+            s2 = reconcile_tail.reconcile(self._config(), hook_input=hook)
+        self.assertEqual(s2["skipped_clean"], 1)
+        self.assertEqual(s2["enqueued"], 0)
+        self.assertEqual(len(self._pending_entries()), 0)
+
+    # -- the no-loss guard: an earlier sibling blocks the tail's advance --------
+    def test_tail_drain_does_not_advance_while_earlier_sibling_queued(self):
+        session = "drainB"
+        ordered = [
+            f"{session}-u0", f"{session}-a0", f"{session}-u1",
+            f"{session}-a1", f"{session}-u2", f"{session}-a2",
+        ]
+        older_doc = f"{session}-r{session}-u0-{session}-a1"
+        tail_doc = f"{session}-r{session}-u0-{session}-a2"
+
+        from lib import pending
+
+        def _payload(doc, content, last_uuid, is_tail):
+            return {
+                "api_url": "http://fake", "api_token": None, "bank_id": "test-bank",
+                "content": content, "document_id": doc, "context": "claude-code",
+                "metadata": {}, "tags": [], "observation_scopes": None,
+                "reconcile_session_id": session,
+                "reconcile_last_uuid": last_uuid,
+                "reconcile_ordered_uuids": ordered,
+                "reconcile_is_tail": is_tail,
+            }
+
+        # The earlier remainder (mid-transcript last_uuid) is enqueued FIRST so
+        # it sorts ahead of the tail in the oldest-first drain order.
+        pending.enqueue(
+            _payload(older_doc, "older remainder turns", f"{session}-a1", False),
+            RuntimeError("reconcile deferred"),
+        )
+        import time as _t
+        _t.sleep(0.002)
+        pending.enqueue(
+            _payload(tail_doc, "tail turns", f"{session}-a2", True),
+            RuntimeError("reconcile deferred"),
+        )
+        self.assertEqual(len(self._pending_entries()), 2)
+
+        # Upstream: the tail commits, but the earlier remainder still fails, so
+        # it stays queued through the whole drain run.
+        posted = []
+
+        def fake_retain(self_c, bank_id=None, content=None,
+                        document_id="conversation", **kw):
+            posted.append(document_id)
+            if document_id == older_doc:
+                raise RuntimeError("earlier remainder still failing upstream")
+            return {"ok": True}
+
+        from drain_pending import drain
+        with mock.patch.object(HindsightClient, "retain", fake_retain):
+            drain(self._config())
+
+        # The tail POST succeeded and its entry was retired ...
+        self.assertIn(tail_doc, posted)
+        remaining = [e["document_id"] for _p, e in self._pending_entries()]
+        self.assertNotIn(tail_doc, remaining)
+        # ... but the watermark did NOT advance: an earlier, still-unconfirmed
+        # sibling of the same session is queued, and advancing past it would
+        # risk silent loss of the remainder (#4571 no-loss guard).
+        self.assertIsNone(watermark.load(session))
+        # The earlier remainder is still queued (its POST failed).
+        self.assertIn(older_doc, remaining)
+
+
 def _stdin(obj):
     import io
     return io.StringIO(json.dumps(obj))

package/vendor/hindsight-memory/settings.json

@@ -6,7 +6,7 @@
   "autoRecall": true,
   "autoRetain": true,
   "retainMode": "full-session",
-  "recallBudget": "low",
+  "recallBudget": "mid",
   "recallMaxTokens": 1024,
   "recallMaxMemories": 12,
   "recallTypes": ["world", "experience"],
@@ -26,7 +26,7 @@
   "retainToolCalls": true,
   "retainTags": ["{session_id}"],
   "retainMetadata": {},
-  "retainContext": "claude-code",
+  "retainContext": "Transcript of Claude Code agent '{agent}' ({bank_id}). 'assistant'/tool lines are the agent's own first-person actions (experience); 'user' lines are the human operator speaking (their statements are world facts).",
   "hindsightApiToken": null,
   "apiPort": 9077,
   "daemonIdleTimeout": 0,

package/vendor/hindsight-memory/tests/test_config.py

@@ -42,8 +42,13 @@ class TestLoadConfig:
         cfg = load_config()
         assert cfg["autoRecall"] is True
         assert cfg["autoRetain"] is True
-        assert cfg["recallBudget"] == "low"
+        assert cfg["recallBudget"] == "mid"
         assert cfg["retainEveryNTurns"] == 10
+        # Switchroom — speaker-aware retain context template (resolved
+        # per-retain by build_retain_payload). Must carry the {agent} and
+        # {bank_id} slots so the consolidation LLM can attribute speakers.
+        assert "{agent}" in cfg["retainContext"]
+        assert "{bank_id}" in cfg["retainContext"]
 
     def test_settings_json_overrides_defaults(self, tmp_path, monkeypatch):
         monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
@@ -75,7 +80,7 @@ class TestLoadConfig:
         monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
         (tmp_path / "settings.json").write_text("not valid json{{")
         cfg = load_config()
-        assert cfg["recallBudget"] == "low"  # default still applies
+        assert cfg["recallBudget"] == "mid"  # default still applies
 
     def test_null_values_in_settings_json_not_applied(self, tmp_path, monkeypatch):
         monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
@@ -112,7 +117,7 @@ class TestLoadConfig:
         # HOME points to tmp_path where no .hindsight/claude-code.json exists
         monkeypatch.setenv("HOME", str(tmp_path))
         cfg = load_config()
-        assert cfg["recallBudget"] == "low"  # default
+        assert cfg["recallBudget"] == "mid"  # default
 
     def test_env_var_wins_over_user_config(self, tmp_path, monkeypatch):
         plugin_root = tmp_path / "plugin"

package/vendor/hindsight-memory/tests/test_hooks.py

@@ -833,6 +833,11 @@ class TestRetainHook:
             assert captured["body"].get("async") is False
 
     def test_retain_includes_context_label(self, monkeypatch, tmp_path):
+        # Switchroom — the default retainContext is now a speaker-aware
+        # template resolved per-retain: {agent} from SWITCHROOM_AGENT_NAME
+        # and {bank_id} from the target bank. Pin a known agent name so the
+        # resolved label is deterministic regardless of the ambient env.
+        monkeypatch.setenv("SWITCHROOM_AGENT_NAME", "testbot")
         messages = [{"role": "user", "content": "hello"}, {"role": "assistant", "content": "world"}]
         transcript = make_transcript_file(tmp_path, messages)
         hook_input = make_hook_input(transcript_path=transcript)
@@ -846,7 +851,11 @@ class TestRetainHook:
         _run_hook("retain", hook_input, monkeypatch, tmp_path, urlopen_side_effect=capture)
 
         if "body" in captured:
-            assert captured["body"]["items"][0]["context"] == "claude-code"
+            context = captured["body"]["items"][0]["context"]
+            # Template placeholders must be resolved (no literal braces left)
+            # and the agent name must be filled in from the env.
+            assert "{" not in context and "}" not in context
+            assert "agent 'testbot'" in context
 
     def test_disabled_auto_retain_does_not_call_api(self, monkeypatch, tmp_path):
         (tmp_path / "plugin_root").mkdir(exist_ok=True)

package/vendor/hindsight-memory/tests/test_retain_context.py

@@ -0,0 +1,69 @@
+"""Tests for build_retain_payload's speaker-aware retainContext template.
+
+Switchroom — retainContext is no longer the opaque constant "claude-code".
+It is a template resolved per-retain by build_retain_payload's
+_resolve_template, filling {agent} from SWITCHROOM_AGENT_NAME and {bank_id}
+from the target bank so the consolidation LLM knows whose first-person
+experience each transcript line is.
+"""
+
+import pytest
+
+from retain import build_retain_payload
+
+MESSAGES = [
+    {"role": "user", "content": "human fact"},
+    {"role": "assistant", "content": "agent action"},
+]
+
+
+def _build(config, monkeypatch, agent="klanker", bank_id="klanker-main"):
+    if agent is None:
+        monkeypatch.delenv("SWITCHROOM_AGENT_NAME", raising=False)
+    else:
+        monkeypatch.setenv("SWITCHROOM_AGENT_NAME", agent)
+    result = build_retain_payload(
+        config,
+        session_id="sess-1",
+        messages_to_retain=MESSAGES,
+        all_messages=MESSAGES,
+        bank_id=bank_id,
+        api_url="http://localhost:9077",
+        api_token=None,
+    )
+    assert result is not None
+    return result["payload"]["context"]
+
+
+def test_context_template_resolves_agent_and_bank(monkeypatch):
+    context = _build(
+        {"retainContext": "agent '{agent}' ({bank_id})"},
+        monkeypatch,
+        agent="klanker",
+        bank_id="klanker-main",
+    )
+    assert context == "agent 'klanker' (klanker-main)"
+
+
+def test_context_template_agent_empty_outside_switchroom(monkeypatch):
+    context = _build(
+        {"retainContext": "agent '{agent}'"},
+        monkeypatch,
+        agent=None,
+    )
+    assert context == "agent ''"
+
+
+def test_context_default_is_speaker_aware_and_resolved(monkeypatch):
+    # No retainContext in config → build_retain_payload falls back to the
+    # "claude-code" literal, which carries no template vars and is returned
+    # verbatim. The speaker-aware default lives in settings.json / config.py
+    # DEFAULTS and is exercised by test_config; here we assert the fallback
+    # path stays byte-stable.
+    context = _build({}, monkeypatch)
+    assert context == "claude-code"
+
+
+def test_context_plain_string_passthrough(monkeypatch):
+    context = _build({"retainContext": "just plain text"}, monkeypatch)
+    assert context == "just plain text"