switchroom 0.21.14 → 0.21.15

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

@@ -243,6 +243,58 @@ class FormatActiveDirectivesBlockTests(unittest.TestCase):
         # The in-prompt footer is still emitted (agent-facing signal).
         self.assertIn("(+4 more, omitted)", out)
 
+    def test_overflow_footer_is_loud_and_operator_directed(self):
+        """memory-RFC P7 — the in-prompt overflow notice must be LOUD and tell
+        the agent to surface the drop to the operator this turn.
+
+        The pre-P7 block emitted only the quiet `(+N more, omitted)`
+        parenthetical, which reaches the agent but neither states that explicit
+        instructions were dropped nor directs the agent to relay it. This
+        asserts the OUTCOME of the loud in-turn channel: the rendered block, on
+        overflow, names the dropped count, the total, the cap, states the loss
+        in unmistakable terms, and instructs the agent to tell the operator.
+        A test that only checked `(+N more, omitted)` would still pass on the
+        pre-P7 code, so it would not guard this change; these assertions fail
+        without it.
+        """
+        total = MAX_DIRECTIVES + 3
+        directives = [
+            _directive(f"d{i}", f"c{i}", priority=total - i) for i in range(total)
+        ]
+        with patch("sys.stderr", new=StringIO()):
+            out = format_active_directives_block(directives)
+        # A loud, explicitly-labelled overflow banner (not a lone parenthetical).
+        self.assertIn("DIRECTIVE OVERFLOW", out)
+        # Names the loss in unmistakable terms, with count/total/cap.
+        self.assertIn("DROPPED", out)
+        self.assertIn("3 of", out)  # omitted of total
+        self.assertIn(str(total), out)
+        self.assertIn(f"MAX_DIRECTIVES={MAX_DIRECTIVES}", out)
+        # Directs the agent to surface it to the OPERATOR this turn — the
+        # in-turn operator-visible channel P7 adds.
+        self.assertIn("operator", out.lower())
+        self.assertIn("ACTION", out)
+        # The literal marker is retained for the recall_log/doctor cross-checks
+        # and the dedup parser.
+        self.assertIn("(+3 more, omitted)", out)
+
+    def test_no_overflow_banner_when_under_cap(self):
+        """The loud banner must appear ONLY on overflow — an under-cap block is
+        unchanged and carries neither the banner nor the action directive."""
+        directives = [_directive(f"d{i}", f"c{i}", priority=5 - i) for i in range(3)]
+        with patch("sys.stderr", new=StringIO()) as fake_err:
+            out = format_active_directives_block(directives)
+        self.assertNotIn("DIRECTIVE OVERFLOW", out)
+        self.assertNotIn("ACTION", out)
+        self.assertNotIn("more, omitted", out)
+        self.assertEqual(fake_err.getvalue(), "")
+
+    def test_max_directives_is_unchanged_by_p7(self):
+        """P7 is the loud-channel PR only. Raising MAX_DIRECTIVES is a separate,
+        later change (RFC §5 P7: order is non-negotiable). Pin the constant so a
+        cap bump cannot ride in on this change unnoticed."""
+        self.assertEqual(MAX_DIRECTIVES, 30)
+
     def test_count_omitted_directives_matches_the_rendered_footer(self):
         """The recall_log's `directives_omitted` number must equal what the
         block actually dropped — it is the operator-visible record of it."""

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

@@ -0,0 +1,293 @@
+"""Switchroom memory-RFC P1 — incremental SessionEnd sweep, OUTCOME tests.
+
+Before P1 the SessionEnd hook called ``run_retain(force=True)`` which retained
+the WHOLE transcript, duplicating content the per-window retains already landed
+(RFC §1.2). P1 makes the forced chunked sweep slice only the transcript tail
+after the committed watermark, degrading to the whole transcript on any failure
+so the §4.3 hazard (a raise here DELETES a turn) is never triggered.
+
+Stdlib-only (`python3 -m unittest discover tests/`). Every test drives the real
+hook code against a FAKE in-process daemon (no network, no LLM) and asserts
+OUTCOMES — the bytes/turns that actually landed in the bank — not that a code
+path ran.
+"""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+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 retain  # noqa: E402
+from lib import watermark  # noqa: E402
+from lib.client import HindsightClient  # noqa: E402
+
+
+class FakeDaemon:
+    """Records retained documents by document_id with upsert semantics."""
+
+    def __init__(self):
+        self.docs = {}   # document_id -> content
+        self.posts = []  # [(document_id, async_processing)]
+
+    def retain(self, bank_id, content, document_id="conversation", context=None,
+               metadata=None, tags=None, timeout=15, async_processing=True,
+               observation_scopes=None):
+        self.posts.append((document_id, async_processing))
+        # Upsert: same document_id overwrites (the daemon contract §1).
+        self.docs[document_id] = content
+        return {"ok": True}
+
+    def content_blob(self):
+        return "\n".join(self.docs.values())
+
+    def bytes_for(self, session_prefix: str) -> int:
+        """Total stored content bytes across every document for a session."""
+        return sum(
+            len(c.encode("utf-8"))
+            for doc_id, c in self.docs.items()
+            if doc_id.startswith(session_prefix)
+        )
+
+    def last_post_content(self) -> str:
+        return self.docs[self.posts[-1][0]]
+
+
+def _write_transcript(path, n_turns, prefix):
+    """Flat-format JSONL: n_turns human turns, each user+assistant with a uuid."""
+    lines = []
+    for i in range(n_turns):
+        lines.append(json.dumps(
+            {"role": "user", "content": f"user turn {i}", "uuid": f"{prefix}-u{i}"}))
+        lines.append(json.dumps(
+            {"role": "assistant", "content": f"assistant turn {i}", "uuid": f"{prefix}-a{i}"}))
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+
+
+def _stdin(obj):
+    import io
+    return io.StringIO(json.dumps(obj))
+
+
+class IncrementalSweepBase(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="hs-rfc-p1-")
+        self.plugin_root = os.path.join(self.tmp, "plugin_root")
+        self.home = os.path.join(self.tmp, "home")
+        self.data = os.path.join(self.tmp, "data")
+        self.transcripts = os.path.join(self.tmp, "transcripts")
+        for d in (self.plugin_root, self.home, self.data, self.transcripts):
+            os.makedirs(d)
+
+        self._write_settings(8)  # default cadence for these tests; overridable
+
+        self.env = mock.patch.dict(os.environ, {
+            "CLAUDE_PLUGIN_ROOT": self.plugin_root,
+            "CLAUDE_PLUGIN_DATA": self.data,
+            "HOME": self.home,
+            "HINDSIGHT_PENDING_DIR": os.path.join(self.home, ".hindsight", "pending-retains"),
+            "HINDSIGHT_RETAINED_DIR": os.path.join(self.home, ".hindsight", "retained"),
+            "HINDSIGHT_INFLIGHT_LOCK": os.path.join(self.home, ".hindsight", "retain-inflight.lock"),
+            "HINDSIGHT_TRANSCRIPTS_DIR": self.transcripts,
+        }, clear=False)
+        self.env.start()
+        for k in list(os.environ):
+            if k.startswith("HINDSIGHT_") and k not in (
+                "HINDSIGHT_PENDING_DIR", "HINDSIGHT_RETAINED_DIR",
+                "HINDSIGHT_INFLIGHT_LOCK", "HINDSIGHT_TRANSCRIPTS_DIR",
+            ):
+                os.environ.pop(k, None)
+
+        self.daemon = FakeDaemon()
+        self._patches = [
+            mock.patch.object(HindsightClient, "retain", self._fake_retain),
+            mock.patch("retain.get_api_url", return_value="http://fake"),
+        ]
+        for p in self._patches:
+            p.start()
+
+    def _write_settings(self, every_n_turns: int):
+        settings = {
+            "autoRetain": True,
+            "retainMode": "chunked",
+            "retainEveryNTurns": every_n_turns,
+            "retainOverlapTurns": 0,
+            "bankId": "test-bank",
+        }
+        with open(os.path.join(self.plugin_root, "settings.json"), "w") as f:
+            json.dump(settings, f)
+
+    def _fake_retain(self, *a, **kw):
+        return self.daemon.retain(*a, **kw)
+
+    def tearDown(self):
+        for p in self._patches:
+            p.stop()
+        self.env.stop()
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def _hook(self, session):
+        return {
+            "session_id": session,
+            "transcript_path": os.path.join(self.transcripts, f"{session}.jsonl"),
+            "cwd": "/x",
+        }
+
+    def _fire_window(self, session, transcript_turns, turn_count):
+        """Drive a live per-window Stop retain (advances the watermark)."""
+        _write_transcript(self._hook(session)["transcript_path"], transcript_turns, session)
+        with mock.patch("retain.increment_turn_count", return_value=turn_count), \
+                mock.patch("sys.stdin", _stdin(self._hook(session))):
+            retain.main()
+
+
+class TestIncrementalSweep(IncrementalSweepBase):
+
+    def test_two_turn_no_watermark_sweep_retains_both_turns(self):
+        # A short session that never fired a per-window retain has no committed
+        # watermark, so the forced sweep must flush the WHOLE (2-turn) transcript
+        # (RFC §4.2 — short sessions still land on disk).
+        session = "sessShort"
+        _write_transcript(self._hook(session)["transcript_path"], 2, session)
+        self.assertIsNone(watermark.load(session))  # precondition: no watermark
+
+        result = retain.run_retain(self._hook(session), force=True)
+
+        self.assertEqual(result.get("status"), "ok")
+        blob = self.daemon.content_blob()
+        self.assertIn("user turn 0", blob)
+        self.assertIn("user turn 1", blob)
+
+    def test_thirty_turn_sweep_is_incremental_and_smaller_than_full(self):
+        # Windows fire at turns 8/16/24 (n=8, overlap 0), then SessionEnd sweeps.
+        # The sweep must contain ONLY turns after the last window's tail uuid,
+        # and the total bytes stored for the session must be strictly less than
+        # the pre-change (full-session sweep) total. This is the test that fails
+        # on the bug it guards: a non-incremental sweep re-stores all 30 turns,
+        # so the totals become equal and assertLess fires.
+        inc = "sessInc"
+        for fire_at in (8, 16, 24):
+            self._fire_window(inc, fire_at, fire_at)
+        # The last window committed its tail uuid as the watermark.
+        wm = watermark.load(inc)
+        self.assertIsNotNone(wm, "expected the per-window retains to commit a watermark")
+        self.assertEqual(wm["last_uuid"], f"{inc}-a23")
+
+        _write_transcript(self._hook(inc)["transcript_path"], 30, inc)
+        result = retain.run_retain(self._hook(inc), force=True)
+        self.assertEqual(result.get("status"), "ok")
+
+        sweep = self.daemon.last_post_content()
+        # Only turns AFTER the watermark (24..29); nothing at/ before it.
+        for i in range(24, 30):
+            self.assertIn(f"user turn {i}", sweep, f"turn {i} missing from incremental sweep")
+        for i in (0, 15, 23):
+            self.assertNotIn(f"user turn {i}", sweep,
+                             f"turn {i} leaked into the incremental sweep")
+
+        # Pre-change baseline: identical scenario, but the SessionEnd sweep runs
+        # full-session (watermark unseen), on a distinct session id in the same
+        # daemon so window docs are directly comparable.
+        full = "sessFull"
+        for fire_at in (8, 16, 24):
+            self._fire_window(full, fire_at, fire_at)
+        _write_transcript(self._hook(full)["transcript_path"], 30, full)
+        with mock.patch("retain.watermark.load", return_value=None):
+            self.assertEqual(retain.run_retain(self._hook(full), force=True).get("status"), "ok")
+
+        self.assertLess(
+            self.daemon.bytes_for(inc),
+            self.daemon.bytes_for(full),
+            "incremental sweep did not reduce total retained bytes vs full sweep",
+        )
+
+    def test_corrupt_watermark_json_sweeps_whole_transcript_no_raise(self):
+        # A watermark file corrupted to invalid JSON must degrade to a whole
+        # -transcript sweep, and no exception may escape run_retain (§4.3).
+        session = "sessCorrupt"
+        _write_transcript(self._hook(session)["transcript_path"], 4, session)
+        retained_dir = os.environ["HINDSIGHT_RETAINED_DIR"]
+        os.makedirs(retained_dir, exist_ok=True)
+        with open(os.path.join(retained_dir, f"{session}.json"), "w") as f:
+            f.write("{ this is not valid json ]]]")
+
+        try:
+            result = retain.run_retain(self._hook(session), force=True)
+        except Exception as e:  # noqa: BLE001 - the whole point is nothing escapes
+            self.fail(f"run_retain raised into the SessionEnd seam: {e!r}")
+
+        self.assertEqual(result.get("status"), "ok")
+        blob = self.daemon.content_blob()
+        for i in range(4):
+            self.assertIn(f"user turn {i}", blob)
+
+    def test_watermark_load_raising_degrades_to_full_sweep(self):
+        # Belt-and-braces for the §4.3 catch-all: even if the watermark READ
+        # itself raises an unexpected error, run_retain must NOT propagate it —
+        # it degrades to the whole-transcript sweep.
+        session = "sessBoom"
+        _write_transcript(self._hook(session)["transcript_path"], 4, session)
+
+        def _boom(_):
+            raise RuntimeError("simulated watermark read explosion")
+
+        with mock.patch("retain.watermark.load", side_effect=_boom):
+            try:
+                result = retain.run_retain(self._hook(session), force=True)
+            except Exception as e:  # noqa: BLE001
+                self.fail(f"run_retain propagated a watermark read failure: {e!r}")
+
+        self.assertEqual(result.get("status"), "ok")
+        blob = self.daemon.content_blob()
+        for i in range(4):
+            self.assertIn(f"user turn {i}", blob)
+
+    def test_compacted_watermark_uuid_sweeps_whole_transcript(self):
+        # The watermark anchor was compacted out of the transcript: tail_after
+        # cannot find it and returns the whole transcript (a safe re-upsert).
+        session = "sessCompact"
+        _write_transcript(self._hook(session)["transcript_path"], 4, session)
+        # Commit a watermark whose uuid is NOT present in the transcript.
+        watermark.commit(session, "ghost-uuid-not-in-transcript", "doc-ghost",
+                         ordered_uuids=["ghost-uuid-not-in-transcript"])
+        self.assertEqual(watermark.load(session)["last_uuid"], "ghost-uuid-not-in-transcript")
+
+        result = retain.run_retain(self._hook(session), force=True)
+        self.assertEqual(result.get("status"), "ok")
+        blob = self.daemon.content_blob()
+        for i in range(4):
+            self.assertIn(f"user turn {i}", blob)
+
+    def test_every_n_turns_1_is_byte_identical_full_session(self):
+        # At retainEveryNTurns==1 the document id is {session_id} and a tail slice
+        # would TRUNCATE it (RFC §4.2). The n==1 path must keep the full-session
+        # sweep even when a committed watermark exists — byte-identical to before.
+        self._write_settings(1)
+        session = "sessN1"
+        _write_transcript(self._hook(session)["transcript_path"], 4, session)
+        # A watermark exists (a prior every-turn fire) sitting mid-transcript.
+        watermark.commit(session, f"{session}-a1", "doc-prior",
+                         ordered_uuids=[f"{session}-u{i//2}" if i % 2 == 0 else f"{session}-a{i//2}"
+                                        for i in range(8)])
+        self.assertEqual(watermark.load(session)["last_uuid"], f"{session}-a1")
+
+        result = retain.run_retain(self._hook(session), force=True)
+        self.assertEqual(result.get("status"), "ok")
+
+        # Whole transcript, under the plain {session_id} document id — the tail
+        # slice must NOT have applied.
+        self.assertIn(session, self.daemon.docs, "n==1 sweep must post under the {session_id} id")
+        content = self.daemon.docs[session]
+        for i in range(4):
+            self.assertIn(f"user turn {i}", content, f"turn {i} missing — n==1 sweep was truncated")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,335 @@
+"""RFC phase4 P3 — unit + end-to-end tests for the operator-profile capture nudge.
+
+Ken's first stated want is "save memories about him". Auto-retain stores
+transcript facts, but nothing gives a DETERMINISTIC signal that a durable
+*profile fact* about the operator himself just went by — so profile capture is
+left to model discretion (the same per-agent lottery Stage A measured for
+directives). P3 mirrors the shipped directive-capture nudge (recall.py #2848):
+a POSITIVE regex detects a first-person durable self-statement, a NEGATIVE
+regex scrubs the two false-positive shapes (questions, attributions to others)
+BEFORE the positive match, and on a hit the UserPromptSubmit hook appends a
+terse advisory telling the model to persist it with an explicit retain tagged
+`profile:ken` into the agent's OWN bank. Pure regex — no model callsite.
+
+These tests pin (all OUTCOME assertions):
+  * True positives — the RFC's listed profile shapes fire.
+  * True negatives — questions and third-/second-party attributions do NOT
+    fire (the negative-lookaround guard scrubs them first).
+  * The advisory carries the `profile:ken` tag instruction and targets the
+    agent's OWN bank (not a shared / cross-agent person bank).
+  * End-to-end through recall.main(): the advisory reaches the emitted
+    additionalContext, the recall_log row carries `profile_nudge: true`, and
+    the config knob OFF (`profileCaptureNudge: false`) suppresses both.
+
+Stdlib-only; runs under `python3 -m unittest discover tests/`. The end-to-end
+harness mirrors test_recall_envelope_strip_telemetry.py.
+"""
+
+import io
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+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
+from recall import (  # noqa: E402
+    _PROFILE_CAPTURE_NUDGE,
+    _combine_context,
+    _is_trivial_stateless,
+    looks_like_profile_statement,
+)
+
+
+# First-person durable self-statements that MUST fire the nudge. Drawn from the
+# RFC P3 shapes ("I prefer …", "my … is …", "I always …", "remind me that I …")
+# plus the conservative identity/situation set.
+PROFILE_STATEMENTS = [
+    # --- stated preferences ---
+    "I prefer dark roast coffee",
+    "I'd prefer British spelling in my docs",
+    "my preference is tabs over spaces",
+    # --- durable self-facts: "my <ATTRIBUTE> is/are …" (tight allow-list) ---
+    "my timezone is Australia/Melbourne",
+    "my email is ken@example.com",
+    "my sister is Lisa",
+    "my kids are at school during the day",
+    "my name's Ken",  # contraction form
+    # --- identity / situation ---
+    "I live in Melbourne",
+    "I work at Anthropic",
+    "I'm allergic to peanuts",
+    "I'm based in Australia",
+    # --- durable identity: diet / abstention / "I'm a <noun>" ---
+    "I'm a vegetarian",
+    "I don't eat meat",
+    "call me Ken",
+    # --- tastes (durable like/dislike framing) ---
+    "I hate em-dashes",
+    # --- durable habits ---
+    "I always take my coffee black",
+    "I usually work late on Thursdays",
+    "I never eat red meat",
+    # --- explicit memory framing about the operator himself ---
+    "remind me that I have a standing 9am standup",
+    "remember that I hate em-dashes",
+]
+
+# Questions and attributions that MUST NOT fire — the negative-lookaround guard
+# scrubs these BEFORE the positive match. A false positive here is nudge noise.
+NON_PROFILE = [
+    # --- questions about the operator (not statements of a durable fact) ---
+    "do I prefer tea or coffee?",
+    "what's my timezone?",
+    "where is my email address stored?",
+    "how do I fix this bug",
+    "should I always run the tests first?",
+    "what do I usually do here",
+    "remind me what my calendar looks like",
+    # --- attributions to a third / second party ---
+    "you said I prefer tea",
+    "she claims my code is broken",
+    "he thinks I always overcomplicate things",
+    "they told me my access was revoked",
+    # --- neither: no first-person durable self-fact ---
+    "the project timezone is UTC",
+    "please run the tests",
+    "what time is it",
+    # --- discourse-marker "my <X> is" — not a durable profile fact. The
+    #     positive arm uses a TIGHT identity allow-list, so a free noun never
+    #     reaches the matcher; these confirm that. ---
+    "my guess is the cache is stale",
+    "my point is that we should ship it",
+    "my concern is the timeout",
+    # --- transient dev state "my <transient> is/are …". These are the exact
+    #     over-fires the free-`\w+` arm produced; the allow-list must NOT fire
+    #     on them (RFC favour-false-negatives constraint on this agent). ---
+    "my container is down",
+    "my build is failing",
+    "my code is broken",
+    "my PR is ready",
+    "my worktree is dirty",
+    "my server is down",
+    "my deploy is stuck",
+    "my tests are green",
+    "my branch is merged",
+    # --- pleasantry embedding a bare always/never after "I" ---
+    "I always appreciate your help",
+    "I never enjoy waiting, but thanks",
+    # --- "I'm a <hedge>" is a transient mood, not an "I'm a <noun>" identity ---
+    "I'm a bit tired",
+    "I'm a little confused about the config",
+    "I'm a big fan of shipping fast",
+    # --- "call me <phrasing>" as a request, not a name form ---
+    "call me back later",
+    "call me when the build finishes",
+    # --- the <channel …> envelope wrapper on its own must never trigger ---
+    '<channel user="ken" chat_id="123">',
+]
+
+
+class TestProfileDetection(unittest.TestCase):
+    def test_profile_statements_fire_the_nudge(self):
+        for p in PROFILE_STATEMENTS:
+            with self.subTest(prompt=p):
+                self.assertTrue(
+                    looks_like_profile_statement(p),
+                    f"expected profile detection for {p!r}",
+                )
+
+    def test_questions_and_attributions_do_not_fire(self):
+        for p in NON_PROFILE:
+            with self.subTest(prompt=p):
+                self.assertFalse(
+                    looks_like_profile_statement(p),
+                    f"FALSE POSITIVE: profile nudge would fire for {p!r}",
+                )
+
+    def test_empty_and_non_string_are_false(self):
+        for bad in ("", "   ", None, 123, [], {}):
+            with self.subTest(value=bad):
+                self.assertFalse(looks_like_profile_statement(bad))
+
+    def test_attribution_scrub_does_not_mask_a_real_self_fact(self):
+        # A message that opens with an attributed clause AND then states the
+        # operator's own durable fact must still fire — the negative guard
+        # scrubs only the attributed span (through end-of-sentence).
+        self.assertTrue(
+            looks_like_profile_statement(
+                "she thinks I'm wrong. my timezone is Melbourne"
+            )
+        )
+
+    def test_attribution_scrub_stops_at_a_comma(self):
+        # The attributed span must stop at a comma, not run to end-of-sentence:
+        # a real self-fact trailing the attributed clause in the SAME sentence
+        # must still reach the positive matcher (MINOR: greedy [^.?!]* → [^.?!,]*).
+        self.assertTrue(
+            looks_like_profile_statement(
+                "she said the deploy failed, my timezone is Melbourne"
+            )
+        )
+
+
+class TestProfileNudgeString(unittest.TestCase):
+    def test_nudge_carries_the_profile_ken_tag_instruction(self):
+        self.assertIn("profile:ken", _PROFILE_CAPTURE_NUDGE)
+        self.assertIn("retain", _PROFILE_CAPTURE_NUDGE)
+        self.assertIn("profile_capture_check", _PROFILE_CAPTURE_NUDGE)
+
+    def test_nudge_targets_the_agents_own_bank_not_a_shared_one(self):
+        # Constraint 2 forbids a cross-agent person bank — the advisory must
+        # route to the agent's OWN bank and say so explicitly.
+        self.assertIn("OWN bank", _PROFILE_CAPTURE_NUDGE)
+        self.assertIn("shared", _PROFILE_CAPTURE_NUDGE)
+
+    def test_combine_appends_nudge_after_recall_block(self):
+        base = "<hindsight_memories>\n…\n</hindsight_memories>"
+        out = _combine_context(base, _PROFILE_CAPTURE_NUDGE)
+        self.assertTrue(out.startswith(base))
+        self.assertTrue(out.endswith(_PROFILE_CAPTURE_NUDGE))
+
+
+class TestTrivialSkipUnaffected(unittest.TestCase):
+    """A profile statement carries personal/stateful signal and must never be
+    trivial-stateless-skipped; greetings still are."""
+
+    def test_profile_statements_are_never_trivial_skipped(self):
+        for p in PROFILE_STATEMENTS:
+            with self.subTest(prompt=p):
+                self.assertFalse(
+                    _is_trivial_stateless("", p),
+                    f"profile statement {p!r} was trivial-skipped",
+                )
+
+
+# --- End-to-end harness (mirrors test_recall_envelope_strip_telemetry.py) ---
+
+
+class _RecordingClient:
+    def __init__(self, memories=None, directives=None):
+        self._memories = memories if memories is not None else []
+        self._directives = directives if directives is not None else []
+        self.queries = []
+
+    def list_directives(self, bank_id, active_only=True, timeout=2):
+        return {"items": list(self._directives)}
+
+    def recall(self, bank_id, query, **kwargs):
+        self.queries.append(query)
+        return {"results": list(self._memories)}
+
+
+def _run_main_with(client, prompt, config_extra=None):
+    hook_input = {
+        "prompt": prompt,
+        "session_id": "test-session",
+        "transcript_path": "",
+        "cwd": "/tmp",
+    }
+    config = {
+        "autoRecall": True,
+        "bankId": "test-bank",
+        "recallMaxTokens": 1024,
+        "recallBudget": "mid",
+        "recallContextTurns": 1,
+        "recallMaxQueryChars": 800,
+        "recallPromptPreamble": "",
+    }
+    if config_extra:
+        config.update(config_extra)
+
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    with patch.object(recall, "load_config", return_value=config), patch.object(
+        recall, "get_api_url", return_value="http://localhost:18888"
+    ), patch.object(recall, "HindsightClient", return_value=client), patch.object(
+        recall, "ensure_bank_mission", return_value=None
+    ), patch.object(recall, "write_state", return_value=None), patch(
+        "sys.stdin", new=io.StringIO(json.dumps(hook_input))
+    ), patch("sys.stdout", new=stdout), patch("sys.stderr", new=stderr):
+        recall.main()
+
+    raw = stdout.getvalue()
+    if not raw.strip():
+        return None, raw
+    parsed = json.loads(raw)
+    return parsed["hookSpecificOutput"]["additionalContext"], raw
+
+
+# A profile-only prompt: matches the profile regex but NOT the directive regex,
+# so these end-to-end assertions isolate the profile nudge cleanly.
+PROFILE_PROMPT = "my timezone is Australia/Melbourne"
+
+
+class _LogTestBase(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.mkdtemp(prefix="profile-nudge-test-")
+        self._prev = os.environ.get("CLAUDE_PLUGIN_DATA")
+        os.environ["CLAUDE_PLUGIN_DATA"] = self._tmpdir
+
+    def tearDown(self):
+        shutil.rmtree(self._tmpdir, ignore_errors=True)
+        if self._prev is None:
+            os.environ.pop("CLAUDE_PLUGIN_DATA", None)
+        else:
+            os.environ["CLAUDE_PLUGIN_DATA"] = self._prev
+
+    def _read_log(self):
+        path = os.path.join(self._tmpdir, "state", "recall_log.jsonl")
+        if not os.path.isfile(path):
+            return []
+        with open(path, encoding="utf-8") as f:
+            return [json.loads(line) for line in f if line.strip()]
+
+
+class ProfileNudgeEndToEnd(_LogTestBase):
+    def test_advisory_reaches_context_and_row_records_it(self):
+        client = _RecordingClient(memories=[{"text": "m", "type": "fact",
+                                             "mentioned_at": "2026-01-01", "id": "m1"}])
+        ctx, _raw = _run_main_with(client, prompt=PROFILE_PROMPT)
+        # The profile advisory is injected into the turn context, tagged and
+        # own-bank-scoped.
+        self.assertIsNotNone(ctx)
+        self.assertIn("profile:ken", ctx)
+        self.assertIn("OWN bank", ctx)
+        # The recall_log row carries the firing-rate boolean.
+        entries = self._read_log()
+        self.assertEqual(len(entries), 1)
+        self.assertTrue(entries[0]["profile_nudge"])
+
+    def test_knob_off_suppresses_nudge_and_row_is_false(self):
+        client = _RecordingClient(memories=[{"text": "m", "type": "fact",
+                                             "mentioned_at": "2026-01-01", "id": "m1"}])
+        ctx, _raw = _run_main_with(
+            client, prompt=PROFILE_PROMPT,
+            config_extra={"profileCaptureNudge": False},
+        )
+        # Nudge suppressed: the advisory is absent from context (memories may
+        # still be injected, but never the profile block).
+        if ctx is not None:
+            self.assertNotIn("profile:ken", ctx)
+            self.assertNotIn("profile_capture_check", ctx)
+        entries = self._read_log()
+        self.assertEqual(len(entries), 1)
+        self.assertFalse(entries[0]["profile_nudge"])
+
+    def test_non_profile_prompt_does_not_fire(self):
+        client = _RecordingClient(memories=[{"text": "m", "type": "fact",
+                                             "mentioned_at": "2026-01-01", "id": "m1"}])
+        ctx, _raw = _run_main_with(client, prompt="please run the tests")
+        if ctx is not None:
+            self.assertNotIn("profile:ken", ctx)
+        entries = self._read_log()
+        self.assertEqual(len(entries), 1)
+        self.assertFalse(entries[0]["profile_nudge"])
+
+
+if __name__ == "__main__":
+    unittest.main()