switchroom 0.19.27 → 0.19.29

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

@@ -12,6 +12,8 @@ single deterministic id), 6 (watermark monotonicity + uuid-not-found), 7
 bound ENQUEUES the remainder).
 """
 
+import contextlib
+import io
 import json
 import os
 import shutil
@@ -41,12 +43,16 @@ class FakeDaemon:
 
     def __init__(self):
         self.docs = {}          # document_id -> {content, metadata, async}
+        # switchroom: the observation_scopes kwarg each POST carried.
+        self.observation_scopes_seen = []
         self.posts = []         # [(document_id, async_processing)]
         self.fail = False
         self.drop_async = False
 
     def retain(self, bank_id, content, document_id="conversation", context=None,
-               metadata=None, tags=None, timeout=15, async_processing=True):
+               metadata=None, tags=None, timeout=15, async_processing=True,
+               observation_scopes=None):
+        self.observation_scopes_seen.append(observation_scopes)
         self.posts.append((document_id, async_processing))
         if self.fail:
             raise RuntimeError("simulated daemon failure")
@@ -390,6 +396,159 @@ class TestSidechainSkip(DurabilityTestBase):
             self.assertIn(f"user turn {i}", blob)
 
 
+class TestObservationScopes(DurabilityTestBase):
+    """switchroom — the per-row observation scope on the LIVE retain paths.
+
+    Asserts the OUTCOME on the wire: what scope the Stop hook, the boot
+    reconciler, and the pending-queue drain actually POST with. Each of those
+    is a separate hand-enumerated kwarg list, so each needs its own pin — a
+    miss on any one silently drops that path back to per-tag scopes.
+    """
+
+    def _hook(self, session="scopesess", n=5):
+        tpath = os.path.join(self.transcripts, f"{session}.jsonl")
+        _write_transcript(tpath, n, session_prefix=session)
+        return {"session_id": session, "transcript_path": tpath, "cwd": "/x"}
+
+    def _set_scope(self, value):
+        os.environ["HINDSIGHT_OBSERVATION_SCOPES"] = value
+        self.addCleanup(os.environ.pop, "HINDSIGHT_OBSERVATION_SCOPES", None)
+
+    # -- default: nothing changes -------------------------------------------
+    def test_unconfigured_stop_retain_posts_no_scope(self):
+        hook = self._hook("plainsess")
+        with mock.patch("retain.increment_turn_count", return_value=3), \
+             mock.patch("sys.stdin", _stdin(hook)):
+            retain.main()
+        self.assertTrue(self.daemon.observation_scopes_seen)
+        self.assertTrue(all(s is None for s in self.daemon.observation_scopes_seen))
+
+    # -- Stop hook (retain.py) ----------------------------------------------
+    def test_configured_stop_retain_posts_the_scope(self):
+        self._set_scope("shared")
+        hook = self._hook("livesess")
+        with mock.patch("retain.increment_turn_count", return_value=3), \
+             mock.patch("sys.stdin", _stdin(hook)):
+            retain.main()
+        self.assertTrue(self.daemon.observation_scopes_seen)
+        self.assertTrue(all(s == "shared" for s in self.daemon.observation_scopes_seen))
+
+    # -- boot reconciler (reconcile_tail.py) --------------------------------
+    def test_configured_boot_reconcile_posts_the_scope(self):
+        self._set_scope("shared")
+        hook = self._hook("reconsess")
+        reconcile_tail.reconcile(self._config(), hook_input=hook)
+        self.assertTrue(self.daemon.observation_scopes_seen)
+        self.assertTrue(all(s == "shared" for s in self.daemon.observation_scopes_seen))
+
+    # -- durability: the scope survives the pending queue --------------------
+    def test_scope_survives_failure_enqueue_and_drain(self):
+        self._set_scope("shared")
+        hook = self._hook("failsess")
+
+        # The daemon refuses, so the Stop retain is ENQUEUED rather than landed.
+        self.daemon.fail = True
+        with mock.patch("retain.increment_turn_count", return_value=3), \
+             mock.patch("sys.stdin", _stdin(hook)):
+            retain.main()
+        entries = self._pending_entries()
+        self.assertEqual(len(entries), 1)
+        _path, entry = entries[0]
+        # The queued entry carries the scope, so the drain does not have to
+        # re-resolve config that may have changed since.
+        self.assertEqual(entry["observation_scopes"], "shared")
+
+        # Drain it hours later: it lands in the SAME scope.
+        import drain_pending
+        seen = []
+
+        class _Client:
+            def __init__(self, *a, **kw):
+                pass
+
+            def retain(self, **kwargs):
+                seen.append(kwargs.get("observation_scopes"))
+                return {"ok": True}
+
+        with mock.patch.object(drain_pending, "HindsightClient", _Client):
+            drain_pending._retry_one(entry, timeout=15)
+        self.assertEqual(seen, ["shared"])
+
+    # -- a typo must never destroy a memory ---------------------------------
+    #
+    # These are the regression tests for the worst bug the validation
+    # introduced. `build_retain_payload` used to RAISE on an off-list value.
+    # It is called from `run_retain`, which `retain.main` calls WITHOUT a
+    # try/except before its `pending_enqueue` — so the raise unwound past the
+    # enqueue: nothing POSTed, nothing queued, watermark not advanced, the turn
+    # gone. `session_end.py` caught it but had no payload to queue, and
+    # `session_start.py` swallowed the same raise into `debug_log` and aborted
+    # the reconcile loop that would have re-derived it. Every producer lost its
+    # memory outright, permanently and silently, for as long as the bad value
+    # sat in the config — switchroom #3244's shape, which this feature cites.
+    #
+    # A misconfigured scope is recoverable. A deleted turn is not. So a bad
+    # value degrades to the PRE-FEATURE behaviour (no field on the wire, the
+    # engine's own default scope) and is shouted about on stderr.
+
+    def test_a_typo_does_not_destroy_the_live_stop_retain(self):
+        self._set_scope("shred")  # not "shared"
+        hook = self._hook("typolivesess")
+        err = io.StringIO()
+        with mock.patch("retain.increment_turn_count", return_value=3), \
+             mock.patch("sys.stdin", _stdin(hook)), \
+             contextlib.redirect_stderr(err):
+            retain.main()
+
+        # OUTCOME 1: the memory LANDED. Not "an exception was caught" — the
+        # turns are in the bank.
+        # (chunked mode with retainEveryNTurns=3 slices the last 3 turns)
+        blob = self.daemon.content_blob()
+        self.assertIn("user turn 4", blob)
+        # OUTCOME 2: at the engine's own default scope (field omitted), which
+        # is exactly what an unconfigured agent does.
+        self.assertTrue(self.daemon.observation_scopes_seen)
+        self.assertTrue(all(s is None for s in self.daemon.observation_scopes_seen))
+        # OUTCOME 3: and it was loud. A silent downgrade would be the original
+        # "typo ignored forever" defect.
+        self.assertIn("shred", err.getvalue())
+        self.assertIn("observation_scopes", err.getvalue())
+
+    def test_a_typo_does_not_destroy_a_FAILED_stop_retain(self):
+        # The reviewer's reproduction: with the raise in place this enqueued 0
+        # entries and left the watermark unmoved, so the turn was lost for good.
+        self._set_scope("shred")
+        hook = self._hook("typofailsess")
+
+        self.daemon.fail = True
+        with mock.patch("retain.increment_turn_count", return_value=3), \
+             mock.patch("sys.stdin", _stdin(hook)), \
+             contextlib.redirect_stderr(io.StringIO()):
+            retain.main()
+
+        # OUTCOME: the payload was still built and still ENQUEUED, so the next
+        # SessionStart drain replays it. This is the assertion that matters —
+        # the memory has a durable on-disk copy.
+        entries = self._pending_entries()
+        self.assertEqual(len(entries), 1)
+        _path, entry = entries[0]
+        self.assertIn("user turn 4", entry["content"])
+        self.assertIsNone(entry["observation_scopes"])
+
+    def test_a_typo_does_not_destroy_the_boot_reconcile(self):
+        # session_start.py swallows a reconcile raise into debug_log AND aborts
+        # the loop on the first bad payload, so the recovery path that would
+        # re-derive lost turns did nothing either.
+        self._set_scope("shred")
+        hook = self._hook("typoreconsess")
+        with contextlib.redirect_stderr(io.StringIO()):
+            reconcile_tail.reconcile(self._config(), hook_input=hook)
+        blob = self.daemon.content_blob()
+        self.assertIn("user turn 0", blob)
+        self.assertTrue(self.daemon.observation_scopes_seen)
+        self.assertTrue(all(s is None for s in self.daemon.observation_scopes_seen))
+
+
 def _stdin(obj):
     import io
     return io.StringIO(json.dumps(obj))

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

@@ -289,7 +289,7 @@ class BoundedRead(unittest.TestCase):
 
 
 class RunSubagentRetain(unittest.TestCase):
-    def _run(self, hook_input):
+    def _run(self, hook_input, config_extra=None):
         captured = {}
 
         class _Client:
@@ -300,7 +300,8 @@ class RunSubagentRetain(unittest.TestCase):
                 captured.update(kwargs)
                 return {"ok": True}
 
-        with mock.patch("subagent_retain.load_config", return_value=dict(CONFIG)), \
+        config = dict(CONFIG, **(config_extra or {}))
+        with mock.patch("subagent_retain.load_config", return_value=config), \
                 mock.patch("subagent_retain.get_api_url", return_value="http://x"), \
                 mock.patch("subagent_retain.ensure_bank_mission"), \
                 mock.patch("subagent_retain.derive_bank_id", return_value="agentbank"), \
@@ -336,6 +337,43 @@ class RunSubagentRetain(unittest.TestCase):
         self.assertEqual(captured["context"], "claude-code-sidechain")
         self.assertEqual(captured["metadata"]["parent_session_id"], "parentsess")
 
+    def test_sidechain_retain_omits_the_scope_when_unconfigured(self):
+        # switchroom — default behaviour must be byte-identical: the sidechain
+        # POST carries no scope, so the engine default stands.
+        with tempfile.TemporaryDirectory() as d:
+            sc = os.path.join(d, "agent-af5.jsonl")
+            _write_sidechain(sc, 8, chars_per_msg=400)
+            hook_input = {
+                "session_id": "parentsess",
+                "agent_id": "af5",
+                "agent_transcript_path": sc,
+                "transcript_path": os.path.join(d, "parentsess.jsonl"),
+                "cwd": d,
+            }
+            result, captured = self._run(hook_input)
+        self.assertEqual(result["status"], "ok")
+        self.assertIsNone(captured["observation_scopes"])
+
+    def test_sidechain_retain_posts_the_configured_scope(self):
+        # switchroom — sidechain retains are their own hand-enumerated kwarg
+        # list; without this pin they would silently keep per-tag scopes while
+        # the parent session's retains moved to the shared one.
+        with tempfile.TemporaryDirectory() as d:
+            sc = os.path.join(d, "agent-af5.jsonl")
+            _write_sidechain(sc, 8, chars_per_msg=400)
+            hook_input = {
+                "session_id": "parentsess",
+                "agent_id": "af5",
+                "agent_transcript_path": sc,
+                "transcript_path": os.path.join(d, "parentsess.jsonl"),
+                "cwd": d,
+            }
+            result, captured = self._run(
+                hook_input, config_extra={"observationScopes": "shared"}
+            )
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(captured["observation_scopes"], "shared")
+
     def test_document_id_is_stable_across_refires(self):
         with tempfile.TemporaryDirectory() as d:
             sc = os.path.join(d, "agent-af5.jsonl")

package/vendor/hindsight-memory/settings.json

@@ -2,7 +2,7 @@
   "hindsightApiUrl": "",
   "bankId": "claude_code",
   "bankMission": "You are a Claude Code AI assistant. Focus on technical discussions, decisions, and context relevant to the user's projects.",
-  "retainMission": "Extract durable facts that will still be true and useful weeks from now: user preferences and standing rules, ongoing projects and recurring commitments, technical and architectural decisions with their rationale, and people/tool relationships. A preference revealed by a request is durable — record the preference (what the user likes, wants, or always does), not the request itself.\n\nA TOOL RESULT IS NOT A FACT. Before extracting, ask: is the subject of this\ncandidate a file path, a command/process/agent/session id, a temp directory, or\nthe location where some output was written? If yes, drop it — it is transcript\nexhaust, not memory.\n\nNEVER extract:\n- Tool results verbatim or paraphrased. Concretely, never produce a fact whose\n  text resembles any of these: \"File created successfully at /path/to/file\",\n  \"A background command with ID bctz4yskm is running, and its output will be\n  written to /tmp/...\", \"Async agent a745598ba84e71df1 was launched successfully\n  and is running in the background\", \"User executed a Bash command to sleep for\n  200 seconds\", \"The assistant used grep to locate 'truncateSync' in src/foo.ts\".\n- Anything mentioning a path under /tmp, a scratchpad directory, or a .tmp file.\n- Agent tool-use traces or narration of what the assistant did (e.g. \"the\n  assistant used X to query Y\", \"ran a search\", \"sent the message\").\n- In-flight workflow/process narration (a sub-task started, paused, or is still\n  running) — retain the outcome only once the task completes or a decision is made.\n- Operation, request, batch, agent, command or session IDs, UUIDs, hashes, or error codes.\n- Slash commands the user typed and their effects (e.g. \"User issued /clear to\n  reset assistant state\").\n- Hindsight's own errors, retries, backlogs, or internal state — the memory\n  system's self-reports are not memories.\n- Restatements of the user's current request or the task in progress.\n- Transient state (unread counts, build status, what is running right now) unless\n  the fact is explicitly dated, in which case record it as a dated observation.\n- Greetings, acknowledgements, and routine operational chatter.\n\nIf a candidate fact matches an exclusion, drop it rather than rewording it. If\nnothing durable remains, return an empty facts list.",
+  "retainMission": "Extract durable facts that will still be true and useful weeks from now: user preferences and standing rules, ongoing projects and recurring commitments, technical and architectural decisions with their rationale, and people/tool relationships. A preference revealed by a request is durable — record the preference (what the user likes, wants, or always does), not the request itself.\n\nA TOOL RESULT IS NOT A FACT. Before extracting, ask: is the subject of this\ncandidate a file path, a command/process/agent/session id, a temp directory, or\nthe location where some output was written? If yes, drop it — it is transcript\nexhaust, not memory.\n\nNEVER extract:\n- Tool results verbatim or paraphrased. Concretely, never produce a fact whose\n  text resembles any of these: \"File created successfully at /path/to/file\",\n  \"A background command with ID bctz4yskm is running, and its output will be\n  written to /tmp/...\", \"Async agent a745598ba84e71df1 was launched successfully\n  and is running in the background\", \"User executed a Bash command to sleep for\n  200 seconds\", \"The assistant used grep to locate 'truncateSync' in src/foo.ts\".\n- Anything mentioning a path under /tmp, a scratchpad directory, or a .tmp file.\n- Agent tool-use traces or narration of what the assistant did (e.g. \"the\n  assistant used X to query Y\", \"ran a search\", \"sent the message\").\n- In-flight workflow/process narration (a sub-task started, paused, or is still\n  running) — retain the outcome only once the task completes or a decision is made.\n- Operation, request, batch, agent, command or session IDs, UUIDs, hashes, or error codes.\n- Slash commands the user typed and their effects (e.g. \"User issued /clear to\n  reset assistant state\").\n- Hindsight's own errors, retries, backlogs, or internal state — the memory\n  system's self-reports are not memories.\n- Restatements of the user's current request or the task in progress.\n- Volatile state written as a timeless assertion. A version, count, size,\n  backlog, status, or any \"X is running Y\" / \"X is at Y\" / \"X is currently Y\"\n  claim is true only at the instant it was said. Concretely, never produce a\n  fact whose text resembles any of these: \"Switchroom fleet is running image\n  version v0.18.19\", \"The switchroom repo is at /path/to/fleet, version\n  v0.19.5\", \"Bank overlord has 43155 pending consolidations\", \"The build is\n  currently green\". If the claim is worth keeping, put the date INSIDE the\n  fact text (\"As of 2026-07-19 the fleet was running v0.18.19\"); if you\n  cannot date it, drop it. An undated one is recalled forever as though it\n  were still true, which is worse than not remembering it at all.\n- Transient state (unread counts, build status, what is running right now) unless\n  the fact is explicitly dated, in which case record it as a dated observation.\n- Greetings, acknowledgements, and routine operational chatter.\n\nIf a candidate fact matches an exclusion, drop it rather than rewording it. If\nnothing durable remains, return an empty facts list.",
   "autoRecall": true,
   "autoRetain": true,
   "retainMode": "full-session",

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

@@ -104,9 +104,18 @@ class TestRecallHook:
             raise OSError("connection refused")
 
         hook_input = make_hook_input(prompt="What is my project about?")
-        # Should not raise — graceful degradation
+        # Should not raise — graceful degradation. Since switchroom #3619 that
+        # degradation is no longer SILENT: an unreachable OWN bank emits the
+        # degraded-recall disclosure, so the agent says "I could not check"
+        # rather than asserting there is no prior context. This case asserted
+        # the pre-#3619 silence and had been RED on main ever since. Nothing
+        # noticed because no CI job ran this file; #3688 wired the suite into
+        # ci-tests-python.yml, which is what surfaced it. The behaviour itself
+        # is pinned CI-side by scripts/tests/test_recall_degraded_notice.py.
         output = _run_hook("recall", hook_input, monkeypatch, tmp_path, urlopen_side_effect=raise_error)
-        assert output.strip() == ""
+        data = json.loads(output)
+        assert data["hookSpecificOutput"]["hookEventName"] == "UserPromptSubmit"
+        assert "DEGRADED" in data["hookSpecificOutput"]["additionalContext"]
 
     def test_output_format_matches_claude_code_spec(self, monkeypatch, tmp_path):
         memory = make_memory("User prefers Python")