switchroom 0.19.38 → 0.19.40

package/telegram-plugin/tests/silence-poke-compaction.test.ts

@@ -0,0 +1,222 @@
+/**
+ * #4058 — mid-turn auto-compaction must not trip the 300s silence fallback.
+ *
+ * The bug: during compaction the model emits zero output and runs zero tools,
+ * so the gateway saw pure silence and fired the framework fallback ("⚠️ no
+ * output for 5 min — the framework ended that stalled turn") on a healthy
+ * turn that completed correctly right after compaction. Observed live:
+ * ~1m50s of tools + ~3m25s compacting = 304s silence → false fire.
+ *
+ * The fix: the PreCompact hook writes a compaction marker; silence-poke gets
+ * an `isCompactionInFlight` dep consulted in the SAME `underCeiling` defer
+ * branch as the #1292/#3519 in-flight-tool defers; the transcript's
+ * `compact_boundary` record (compaction END) clears the marker and counts as
+ * production. These tests drive the REAL tick loop and assert outcomes:
+ *   - a compaction gap past 300s but under the hard ceiling → NO fire;
+ *   - a genuinely-wedged turn (no compaction) → STILL fires at 300s;
+ *   - a compaction stuck past the hard ceiling → STILL fires (bounded defer).
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, existsSync, utimesSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { projectTranscriptLine } from '../session-tail.js'
+import { applySilencePokeSessionEvent } from '../gateway/silence-poke-session-event.js'
+import {
+  COMPACTION_MARKER_FILE,
+  readCompactionMarkerAgeMs,
+  removeCompactionMarker,
+} from '../gateway/compaction-marker.js'
+import * as silencePoke from '../silence-poke.js'
+import * as pendingProgress from '../pending-work-progress.js'
+import {
+  startTurn,
+  __tickForTests,
+  __setDepsForTests,
+  __getStateForTests,
+  __resetAllForTests,
+  DEFAULT_THRESHOLDS,
+  type SilencePokeMetric,
+  type FrameworkFallbackContext,
+} from '../silence-poke.js'
+
+const HARD_CEILING = 900_000 // SILENCE_FALLBACK_HARD_MS default
+
+interface TestFixtures {
+  emitted: SilencePokeMetric[]
+  fallbacks: FrameworkFallbackContext[]
+}
+
+function setupDeps(opts?: {
+  isCompactionInFlight?: (key: string) => boolean
+  isLegitimatelyWorking?: (key: string) => boolean
+}): TestFixtures {
+  const fixtures: TestFixtures = { emitted: [], fallbacks: [] }
+  __setDepsForTests({
+    emitMetric: (e) => fixtures.emitted.push(e),
+    onFrameworkFallback: (ctx) => { fixtures.fallbacks.push(ctx) },
+    thresholdsMs: { ...DEFAULT_THRESHOLDS, fallbackHardCeiling: HARD_CEILING },
+    // Mirror production wiring: the callback path is active (liveness-wiring
+    // always wires isLegitimatelyWorking), returning false = "no tool work".
+    isLegitimatelyWorking: opts?.isLegitimatelyWorking ?? (() => false),
+    ...(opts?.isCompactionInFlight != null
+      ? { isCompactionInFlight: opts.isCompactionInFlight }
+      : {}),
+  })
+  return fixtures
+}
+
+beforeEach(() => {
+  __resetAllForTests()
+  delete process.env.SWITCHROOM_DISABLE_SILENCE_POKE
+})
+
+afterEach(() => {
+  __resetAllForTests()
+})
+
+describe('silence-poke — #4058 compaction defer (outcome)', () => {
+  it('a compaction gap longer than 300s but under the hard ceiling does NOT fire the fallback', () => {
+    // Real observed shape: tools until t=110s, compaction t=110s..415s (305s
+    // of pure silence — past the 300s window), turn completes after.
+    let compacting = false
+    const fx = setupDeps({ isCompactionInFlight: () => compacting })
+    startTurn('chat:1', 0)
+    // Tools produced feed renders until 110s → production reset at 110s.
+    silencePoke.noteProduction('chat:1', 110_000)
+    compacting = true // PreCompact hook fired
+    __tickForTests(300_000) // 190s silent — under threshold anyway
+    __tickForTests(415_000) // 305s silent — WOULD fire without the fix
+    __tickForTests(500_000) // 390s silent — still compacting
+    expect(fx.fallbacks).toHaveLength(0)
+    expect(fx.emitted).toHaveLength(0)
+    // Compaction ends: the compact_boundary handler clears the marker AND
+    // counts the boundary as production (fresh window for the resumed turn).
+    compacting = false
+    silencePoke.noteProduction('chat:1', 505_000)
+    __tickForTests(510_000)
+    expect(fx.fallbacks).toHaveLength(0) // healthy turn: never fired
+  })
+
+  it('a genuinely-wedged turn with no compaction STILL fires at 300s', () => {
+    const fx = setupDeps({ isCompactionInFlight: () => false })
+    startTurn('chat:2', 0)
+    __tickForTests(300_000)
+    expect(fx.fallbacks).toHaveLength(1)
+    expect(fx.emitted.at(-1)).toMatchObject({ kind: 'silence_fallback_sent' })
+  })
+
+  it('a turn that goes silent AFTER compaction ends still fires one window later', () => {
+    let compacting = true
+    const fx = setupDeps({ isCompactionInFlight: () => compacting })
+    startTurn('chat:3', 0)
+    __tickForTests(310_000)
+    expect(fx.fallbacks).toHaveLength(0) // deferred while compacting
+    compacting = false
+    silencePoke.noteProduction('chat:3', 320_000) // compact_boundary landed
+    __tickForTests(325_000)
+    expect(fx.fallbacks).toHaveLength(0)
+    // …but the model never resumes → real wedge → fires 300s after boundary.
+    __tickForTests(620_000)
+    expect(fx.fallbacks).toHaveLength(1)
+  })
+
+  it('a compaction stuck past the hard ceiling STILL fires (bounded defer)', () => {
+    const fx = setupDeps({ isCompactionInFlight: () => true })
+    startTurn('chat:4', 0)
+    __tickForTests(899_000)
+    expect(fx.fallbacks).toHaveLength(0) // deferred under the ceiling
+    __tickForTests(900_000) // silence ≥ fallbackHardCeiling → defer expires
+    expect(fx.fallbacks).toHaveLength(1)
+  })
+
+  it('absent dep (legacy fixtures) leaves behaviour unchanged — fires at 300s', () => {
+    const fx = setupDeps()
+    startTurn('chat:5', 0)
+    __tickForTests(300_000)
+    expect(fx.fallbacks).toHaveLength(1)
+  })
+})
+
+describe('session-tail — compact_boundary projection', () => {
+  it('projects a real transcript compact_boundary line', () => {
+    // Verbatim shape from a live agent transcript (trimmed to the fields the
+    // projection reads).
+    const line = JSON.stringify({
+      parentUuid: null,
+      isSidechain: false,
+      type: 'system',
+      subtype: 'compact_boundary',
+      content: 'Conversation compacted',
+      level: 'info',
+      compactMetadata: { trigger: 'auto', preTokens: 283797, postTokens: 224551, durationMs: 111959 },
+    })
+    expect(projectTranscriptLine(line)).toEqual([
+      { kind: 'compact_boundary', trigger: 'auto', compactDurationMs: 111959 },
+    ])
+  })
+
+  it('tolerates missing compactMetadata', () => {
+    const line = JSON.stringify({ type: 'system', subtype: 'compact_boundary', content: 'Conversation compacted' })
+    expect(projectTranscriptLine(line)).toEqual([
+      { kind: 'compact_boundary', trigger: null, compactDurationMs: null },
+    ])
+  })
+})
+
+describe('compaction-marker + session-event wiring', () => {
+  let dir: string
+  const envBefore = process.env.TELEGRAM_STATE_DIR
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'sp-compact-'))
+    process.env.TELEGRAM_STATE_DIR = dir
+  })
+
+  afterEach(() => {
+    if (envBefore != null) process.env.TELEGRAM_STATE_DIR = envBefore
+    else delete process.env.TELEGRAM_STATE_DIR
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it('readCompactionMarkerAgeMs: absent → null; present → mtime age', () => {
+    expect(readCompactionMarkerAgeMs(dir, 1_000)).toBeNull()
+    const p = join(dir, COMPACTION_MARKER_FILE)
+    writeFileSync(p, '{"ts":1}\n')
+    const at = new Date(Date.now() - 10_000)
+    utimesSync(p, at, at)
+    const age = readCompactionMarkerAgeMs(dir)
+    expect(age).not.toBeNull()
+    expect(age!).toBeGreaterThanOrEqual(9_000)
+    expect(age!).toBeLessThan(60_000)
+    removeCompactionMarker(dir)
+    expect(readCompactionMarkerAgeMs(dir)).toBeNull()
+    removeCompactionMarker(dir) // idempotent
+  })
+
+  it('compact_boundary session event clears the marker and resets the silence clock', () => {
+    writeFileSync(join(dir, COMPACTION_MARKER_FILE), '{"ts":1}\n')
+    startTurn('c:9', 0)
+    setupDeps()
+    applySilencePokeSessionEvent(silencePoke, pendingProgress, 'c:9', {
+      kind: 'compact_boundary',
+      trigger: 'auto',
+      compactDurationMs: 111_959,
+    })
+    expect(existsSync(join(dir, COMPACTION_MARKER_FILE))).toBe(false)
+    // Clock reset: lastOutboundAt stamped by noteProduction.
+    expect(__getStateForTests('c:9')?.lastOutboundAt).not.toBeNull()
+  })
+
+  it('PreCompact hook writes the marker from its stdin payload', () => {
+    const hook = join(__dirname, '..', 'hooks', 'compaction-marker-precompact.mjs')
+    execFileSync('node', [hook], {
+      env: { ...process.env, TELEGRAM_STATE_DIR: dir },
+      input: JSON.stringify({ session_id: 's-1', trigger: 'auto', hook_event_name: 'PreCompact' }),
+    })
+    const age = readCompactionMarkerAgeMs(dir)
+    expect(age).not.toBeNull()
+    expect(age!).toBeLessThan(30_000)
+  })
+})

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

@@ -220,15 +220,18 @@ class HindsightClient:
         tags: Optional[list] = None,
         timeout: int = 15,
         async_processing: bool = True,
-        observation_scopes: Optional[str] = None,
+        observation_scopes: Optional[object] = None,
     ) -> dict:
         """Retain content into a bank's memory.
 
         ``observation_scopes`` is a per-row Hindsight field controlling which
         observation scope consolidation writes this item's observations into.
         ``"shared"`` puts them in ONE global untagged scope instead of a scope
-        per tag. ``None`` (the default) omits the field entirely, so the
-        engine's own default stands and the wire body is byte-identical to a
+        per tag; an explicit ``list[list[str]]`` (e.g. ``[["lesson"]]``, what
+        the ``curated`` strategy emits) declares the exact scope(s) to
+        consolidate into, JSON-serialised onto the wire as a nested array.
+        ``None`` (a falsy value) omits the field entirely, so the engine's own
+        default stands and the wire body is byte-identical to a
         pre-``observation_scopes`` client.
 
         By default posts with ``async=true`` so the server processes extraction
@@ -336,7 +339,7 @@ class HindsightClient:
         tags: Optional[list],
         timeout: int,
         async_processing: bool,
-        observation_scopes: Optional[str] = None,
+        observation_scopes: Optional[object] = None,
     ) -> dict:
         """POST exactly one retain item. Raises on any HTTP/transport error."""
         path = f"/v1/default/banks/{urllib.parse.quote(bank_id, safe='')}/memories"

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

@@ -6,8 +6,30 @@ variable overrides. Full config schema matching Openclaw's 30+ options.
 
 import json
 import os
+import re
 import sys
 
+#: Switchroom-local: strategies for the per-row curated observation scope.
+#: ``curated`` (default) strips volatile provenance tags from the consolidation
+#: scope, keeping stable semantic ones; ``shared`` pools every retain into one
+#: bank-wide untagged scope; ``combined`` / ``off`` emit no per-row scope (the
+#: pre-feature engine default). See ``compute_observation_scopes``.
+OBSERVATION_SCOPE_STRATEGIES = ("curated", "shared", "combined", "off")
+
+#: Tag patterns treated as VOLATILE per-session provenance by ``curated``:
+#: ``parent_session:<id>`` and a bare RFC-4122 UUID (what the ``{session_id}``
+#: retain tag resolves to on the parent path). The UUID pattern also matches
+#: the sidechain-derived ``<uuid>-sub-<agent_id>`` form, because
+#: ``subagent_retain.py`` sets ``sub_session_id = f"{session_id}-sub-{agent_id}"``
+#: and the ``{session_id}`` retain tag resolves to that — a per-invocation-unique
+#: value that, if left in scope, defeats cross-session dedup on the dominant
+#: (sidechain) observation path. A tag matching ANY of these is dropped from the
+#: consolidation scope but LEFT on the source fact.
+DEFAULT_VOLATILE_SCOPE_PATTERNS = (
+    r"^parent_session:",
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(-sub-.+)?$",
+)
+
 DEFAULTS = {
     # Recall
     "autoRecall": True,
@@ -181,6 +203,37 @@ DEFAULTS = {
     # through `defaults.memory.observation_scopes`) via
     # HINDSIGHT_OBSERVATION_SCOPES, exported ONLY when the operator opted in.
     "observationScopes": None,
+    # Switchroom hindsight-leverage — CURATED observation scopes (default ON).
+    # `combined` (the pre-feature engine default) makes consolidation dedup an
+    # observation only against others carrying the IDENTICAL tag set. Because
+    # switchroom stamps volatile per-session provenance on every retain
+    # (`{session_id}` → a bare UUID tag, and `parent_session:<uuid>` /
+    # `sidechain` / `agent_type:*` on sub-agent retains), that turns every
+    # session into its own dedup island — cross-session dedup never happens.
+    #
+    # `curated` (default) strips ONLY the volatile provenance tags
+    # (`observationScopeVolatilePatterns`) from the CONSOLIDATION scope, keeping
+    # the stable semantic ones (`lesson`, `anti-pattern`, `agent_type:*`,
+    # `sidechain`, entities). The stripped tags STAY on the source fact (still
+    # queryable / recall-filterable) — only the observation's dedup scope is
+    # narrowed. Non-empty stable set → the explicit scope `[[stable…]]`; empty
+    # stable set (e.g. a retain tagged only with a session id) → `"shared"`,
+    # one bank-wide untagged scope. This preserves recall tag-weighting on the
+    # observation layer (the kept tags still ride the observation) while giving
+    # cross-session dedup. Docs: https://hindsight.vectorize.io/developer/api/retain
+    # ("shared") and /developer/observations (scope isolation via all_strict).
+    #
+    # Opt-out: set `observationScopeStrategy` to `combined` (or `off`) — both
+    # emit no per-row scope, restoring the exact pre-feature engine default. A
+    # manually-pinned `observationScopes` (memory.observation_scopes) STILL wins
+    # over the strategy, so operators who set `per_tag` / `all_combinations` /
+    # `shared` keep that behaviour unchanged.
+    "observationScopeStrategy": "curated",
+    # Tag patterns treated as VOLATILE (stripped from the curated scope, kept on
+    # the source fact). Defaults: `parent_session:<id>` and a bare RFC-4122
+    # UUID (what `{session_id}` resolves to). Overridable via settings.json /
+    # ~/.hindsight/claude-code.json for a bank with an unusual provenance tag.
+    "observationScopeVolatilePatterns": list(DEFAULT_VOLATILE_SCOPE_PATTERNS),
     # Switchroom hindsight-leverage E2 / PR9 (#398) — lesson & anti-pattern
     # tagging at retain time. When on (default), build_retain_payload scans the
     # formatted transcript slice for explicit lesson / anti-pattern markers and
@@ -333,6 +386,11 @@ ENV_OVERRIDES = {
     # defaults.memory.observation_scopes) ONLY when the operator set it; unset
     # leaves `observationScopes` None and the field off the wire entirely.
     "HINDSIGHT_OBSERVATION_SCOPES": ("observationScopes", str),
+    # Opt-out / override the curated default. `combined` or `off` restore the
+    # pre-feature engine default; `curated` (the shipped default) / `shared`
+    # select the computed strategies. Off-list values fall back to `curated`
+    # (shouted, never raised) — see compute_observation_scopes.
+    "HINDSIGHT_OBSERVATION_SCOPE_STRATEGY": ("observationScopeStrategy", str),
     # Switchroom hindsight-leverage E2 / PR9 (#398) — lesson/anti-pattern tagging
     # + recall demotion toggles and overrides.
     "HINDSIGHT_LESSON_TAGGING": ("lessonTagging", bool),
@@ -513,6 +571,99 @@ def resolve_observation_scopes(config: dict):
     return value
 
 
+def _volatile_scope_matchers(config: dict):
+    """Compile ``observationScopeVolatilePatterns`` to regexes, skipping bad ones.
+
+    NEVER raises: a malformed pattern is dropped (and shouted about) rather than
+    allowed to kill a retain. Falls back to the built-in defaults when the
+    config value is absent or not a list.
+    """
+    raw = config.get("observationScopeVolatilePatterns")
+    if not isinstance(raw, (list, tuple)):
+        raw = DEFAULT_VOLATILE_SCOPE_PATTERNS
+    matchers = []
+    for pat in raw:
+        if not isinstance(pat, str):
+            continue
+        try:
+            matchers.append(re.compile(pat))
+        except re.error as e:
+            print(
+                f"[Hindsight] observationScopeVolatilePatterns entry {pat!r} is not "
+                f"a valid regex ({e}); ignoring it for scope curation.",
+                file=sys.stderr,
+            )
+    return matchers
+
+
+def _is_volatile_scope_tag(tag: str, matchers) -> bool:
+    return any(m.search(tag) for m in matchers)
+
+
+def compute_observation_scopes(tags, config: dict):
+    """Resolve the per-row ``observation_scopes`` value for one retain.
+
+    Returns ``(value, error)`` — exactly like :func:`classify_observation_scopes`
+    — and MUST NEVER RAISE (a bad config must degrade the SCOPE, never lose the
+    turn; see ``retain.build_retain_payload``). ``value`` is what goes on the
+    wire: ``None`` (omit the field entirely → engine default), a bare string
+    (``"shared"`` / an operator-pinned Hindsight scope), or an explicit
+    ``list[list[str]]`` tag matrix. The wire body is byte-identical to the
+    pre-feature client whenever ``value`` is ``None``.
+
+    Precedence:
+
+    1. A manually-pinned ``observationScopes`` (``memory.observation_scopes``)
+       WINS — its classified value (or its degrade-to-None-with-error on a typo)
+       is returned unchanged, so existing operator overrides keep working.
+    2. Otherwise ``observationScopeStrategy`` decides:
+
+       * ``combined`` / ``off`` → ``None`` (pre-feature engine default; opt-out).
+       * ``shared``             → ``"shared"`` uniformly.
+       * ``curated`` (default)  → strip volatile provenance tags from the scope
+         (keeping them on the source fact); non-empty stable set → ``[[stable…]]``
+         (deterministically sorted), empty stable set → ``"shared"``.
+       * anything else          → treated as ``curated`` and shouted about.
+
+    Docs: https://hindsight.vectorize.io/developer/api/retain (``shared`` == the
+    explicit ``[[]]`` scope; a custom ``list[list[str]]`` is consolidated with
+    ``all_strict`` matching so scopes stay isolated) and /developer/observations.
+    """
+    # 1. Operator-pinned scope wins (back-compat). Only fall through to the
+    #    strategy when observationScopes is genuinely UNSET — a typo'd pin
+    #    degrades to the engine default WITH its error, never silently curated.
+    manual, manual_error = classify_observation_scopes(config)
+    if manual is not None or manual_error is not None:
+        return manual, manual_error
+
+    strategy_raw = config.get("observationScopeStrategy")
+    strategy = strategy_raw.strip().lower() if isinstance(strategy_raw, str) else ""
+    if not strategy:
+        strategy = "curated"
+
+    error = None
+    if strategy not in OBSERVATION_SCOPE_STRATEGIES:
+        error = (
+            f"observationScopeStrategy={strategy_raw!r} is not one of "
+            f"{', '.join(OBSERVATION_SCOPE_STRATEGIES)}; using 'curated'."
+        )
+        strategy = "curated"
+
+    if strategy in ("combined", "off"):
+        return None, error
+    if strategy == "shared":
+        return "shared", error
+
+    # curated
+    matchers = _volatile_scope_matchers(config)
+    stable = sorted(
+        {t for t in (tags or []) if isinstance(t, str) and t and not _is_volatile_scope_tag(t, matchers)}
+    )
+    if stable:
+        return [stable], error
+    return "shared", error
+
+
 def _cast_env(value: str, typ):
     """Cast environment variable string to target type. Returns None on failure."""
     try:

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

@@ -28,7 +28,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from lib import watermark
 from lib.bank import derive_bank_id, ensure_bank_mission
 from lib.client import HindsightClient
-from lib.config import classify_observation_scopes, debug_log, load_config
+from lib.config import compute_observation_scopes, debug_log, load_config
 from lib.content import (
     prepare_retention_transcript,
     slice_last_turns_by_user_boundary,
@@ -267,13 +267,13 @@ def build_retain_payload(
     Returns ``{payload, document_id, message_count, last_uuid, ordered_uuids,
     transcript}`` or ``None`` when the slice formats to nothing.
 
-    NEVER raises on a bad ``observationScopes``. Every retain producer builds
-    its payload here, so this seam sees the typo — but it is also the seam the
-    memory itself is made at, and a config typo must not be able to destroy
-    one. An off-list value is dropped from the payload (so the engine's own
-    default stands, exactly as before this feature existed) and shouted about
-    on stderr; the memory is still built, still POSTed, still queued on
-    failure. See ``lib.config.classify_observation_scopes``.
+    NEVER raises on a bad ``observationScopes`` / ``observationScopeStrategy``.
+    Every retain producer builds its payload here, so this seam sees the typo —
+    but it is also the seam the memory itself is made at, and a config typo must
+    not be able to destroy one. An off-list value degrades the SCOPE (the
+    engine's own default stands for a bad pin; ``curated`` stands for a bad
+    strategy) and is shouted about on stderr; the memory is still built, still
+    POSTed, still queued on failure. See ``lib.config.compute_observation_scopes``.
     """
     retain_roles = config.get("retainRoles", ["user", "assistant"])
     include_tool_calls = config.get("retainToolCalls", True)
@@ -367,12 +367,16 @@ def build_retain_payload(
     except Exception:
         pass
 
-    # Per-row observation scope (switchroom). None unless the operator set
-    # memory.observation_scopes — and a None is dropped at the wire by
-    # HindsightClient._retain_one, so the default request body is unchanged.
-    # Carried ON THE PAYLOAD so it survives the pending-retains queue: a retain
-    # that fails and drains hours later must land in the SAME scope it would
-    # have landed in inline.
+    # Per-row observation scope (switchroom). Default `curated`: volatile
+    # per-session provenance tags are stripped from the CONSOLIDATION scope
+    # (kept on the source fact) so observations dedup across sessions instead of
+    # per-session — a non-empty stable tag set yields an explicit `[[stable…]]`
+    # scope, an all-volatile/empty set yields `"shared"`. A None (opt-out via
+    # observationScopeStrategy=combined/off, or a manual observationScopes typo)
+    # is dropped at the wire by HindsightClient._retain_one, so that request
+    # body is byte-identical to the pre-feature default. Carried ON THE PAYLOAD
+    # so it survives the pending-retains queue: a retain that fails and drains
+    # hours later must land in the SAME scope it would have landed in inline.
     #
     # CLASSIFIED, NOT VALIDATED. This is the one seam every retain producer
     # funnels through, which makes it the tempting place to reject a typo — and
@@ -388,7 +392,7 @@ def build_retain_payload(
     # So a bad value degrades to the PRE-FEATURE behaviour (field omitted, the
     # engine's own default scope stands) and is shouted about on stderr. Wrong
     # scope is recoverable; a lost turn is not.
-    scope, scope_error = classify_observation_scopes(config)
+    scope, scope_error = compute_observation_scopes(tags, config)
     if scope_error:
         print(
             f"[Hindsight] observation_scopes IGNORED for this retain: {scope_error} "

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

@@ -172,12 +172,25 @@ class TestBackfill(BackfillTestBase):
         self.assertTrue(all(async_flag is False for _, async_flag in self.daemon.posts))
 
     # -- switchroom: per-row observation scope on the backfill path ---------
-    def test_backfill_omits_the_scope_when_unconfigured(self):
+    def test_backfill_omits_the_scope_when_opted_out(self):
+        # The curated default now emits a scope on every path; the opt-out
+        # (observationScopeStrategy=combined) must stay byte-identical to the
+        # pre-feature body — no scope on the wire, engine default in force.
+        os.environ["HINDSIGHT_OBSERVATION_SCOPE_STRATEGY"] = "combined"
+        self.addCleanup(os.environ.pop, "HINDSIGHT_OBSERVATION_SCOPE_STRATEGY", None)
         self._transcript("clerk", "sess-plain", 4)
         bf.Backfill(self._config(), commit=True, delay_ms=0).run()
         self.assertTrue(self.daemon.observation_scopes_seen)
         self.assertTrue(all(s is None for s in self.daemon.observation_scopes_seen))
 
+    def test_backfill_curates_the_scope_by_default(self):
+        # Default ON: every recovered slice carries a curated scope; a miss here
+        # would silently drop the backfill path back to the pre-feature default.
+        self._transcript("clerk", "sess-plain", 4)
+        bf.Backfill(self._config(), commit=True, delay_ms=0).run()
+        self.assertTrue(self.daemon.observation_scopes_seen)
+        self.assertTrue(all(s is not None for s in self.daemon.observation_scopes_seen))
+
     def test_backfill_posts_the_configured_scope(self):
         # The backfill enumerates its own retain kwargs; a miss here would
         # scatter every recovered historical slice into per-tag scopes while