switchroom 0.19.43 → 0.19.45

package/telegram-plugin/tests/stream-render-golden.test.ts

@@ -25,6 +25,8 @@ import { tmpdir } from 'node:os'
 import {
   handleSessionEvent,
   __resetParkedTurnStartsForTest,
+  flushCompletionTracker,
+  closeFlushCompletionWindows,
   type StreamRenderDeps,
 } from '../gateway/stream-render.js'
 import {
@@ -33,7 +35,7 @@ import {
   type SendReplyRequest,
 } from '../gateway/outbound-send-path.js'
 import { OutboundDedupCache } from '../recent-outbound-dedup.js'
-import { FlushedTurnSupersedeRegistry } from '../flushed-turn-supersede.js'
+import { FlushedTurnSupersedeRegistry, SUPERSEDE_COMPLETED_GRACE_MS } from '../flushed-turn-supersede.js'
 import { BackstopDeliveryLedger } from '../gateway/backstop-delivery.js'
 import { redact } from '../secret-detect/redact.js'
 import { createTurnTypingLoop } from '../gateway/turn-typing-loop.js'
@@ -279,6 +281,9 @@ function makeSendReplyDeps(dedup: OutboundDedupCache, sharedSupersede?: FlushedT
     streamKey: key,
     resolveReplyOwnerTurn: () => ownerRes(null, 'none'),
     getLastSubagentHandbackAt: () => null,
+    // #4176 — no sub-agent live (these suites drive the parent session's own
+    // flush→reply collapse). The gate is exercised in send-reply-golden.test.ts.
+    subagentReplyAuthority: { subagentCouldOwnReply: () => false },
     findTurnByOriginId: () => null,
     findTurnByQuotedMessageId: () => null,
     resolveAnswerThreadWithLog: (_c: string, explicit: number | undefined) => explicit,
@@ -698,3 +703,201 @@ describe('#3544 — turn-start typing is unconditional at the enqueue seam', ()
     rig.emitter.reset()
   })
 })
+
+
+// ── #4173 — the turn-completion window wiring, driven through the REAL paths ──
+//
+// The pure three-phase rule is pinned in flushed-turn-supersede.test.ts /
+// reply-owner-resolve.test.ts; THESE tests pin the stream-render WIRING — the
+// quiescence flush OPENING the window and the real turn_end CLOSING it — which
+// nothing else covers (deleting either hook leaves every pure test green).
+describe('#4173 — quiescence flush opens the completion window; the real turn_end closes it', () => {
+  const settleFlush = () => new Promise((r) => setTimeout(r, 650))
+  const ANSWER =
+    'The composed terminal answer that the model never sent via reply, long enough to be a ' +
+    'genuine substantive flush delivery for the completion-window wiring tests.'
+
+  beforeEach(() => {
+    // drain module-scope tracker state left by other suites
+    flushCompletionTracker.closeAll(Date.now())
+  })
+
+  it('END-TO-END: the synthetic quiescence turn_end OPENS the window (atom + record ' +
+    'claimable far past any fixed TTL); the REAL turn_end then CLOSES both to the ' +
+    'replay grace', async () => {
+    const supersede = new FlushedTurnSupersedeRegistry()
+    // Pre-stamp a bogus value so the OPEN assertion proves the flush branch
+    // actively nulled it (not that it was merely never written).
+    const turn = makeTurn({ capturedText: [ANSWER], realEndObservedAt: 111 } as Partial<CurrentTurn>)
+    const sh = makeStreamDeps({ turn, flushedTurnSupersede: supersede })
+
+    // The answer-ready quiescence flush: a SYNTHETIC turn_end.
+    handleSessionEvent(sh.deps, { kind: 'turn_end', durationMs: -1, reason: 'answer-ready-quiescence' })
+    await settleFlush()
+    expect(sh.delivered).toContain(ANSWER)
+
+    // OPEN: the atom's window was re-opened at fire time…
+    expect((turn as unknown as { realEndObservedAt: number | null }).realEndObservedAt).toBeNull()
+    // …and the record is claimable 20 minutes out (a /compact longer than any
+    // tuned TTL still collapses to one bubble — the #4166 unbounded case).
+    // Removing the flush branch's `flushCompletionTracker.open(turn)` leaves
+    // the record born-completed via turn-end stamping in prod; in this harness
+    // the observable red is the atom assertion above.
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + 20 * 60_000 }).reason,
+    ).toBe('supersede')
+
+    // The session's REAL turn_end lands later — the completion signal.
+    handleSessionEvent(sh.deps, { kind: 'turn_end', durationMs: 1200 })
+    await settleFlush()
+
+    // CLOSED: the atom is stamped…
+    const stamped = (turn as unknown as { realEndObservedAt: number | null }).realEndObservedAt
+    expect(stamped).not.toBeNull()
+    // …the record still honours the bounded tool-call-replay grace…
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + 1_000 }).reason,
+    ).toBe('supersede')
+    // …and EXPIRES past it: a decoupled same-bridge reply (the Task-sub-agent-
+    // after-parent-turn-end shape) can no longer edit over the flushed answer.
+    // Removing the close hook (`closeFlushCompletionWindows` in case 'turn_end')
+    // turns THIS red — the record would stay open for 30 minutes.
+    expect(
+      supersede.peek(CHAT, undefined, {
+        liveTurnId: turn.turnId,
+        now: Date.now() + SUPERSEDE_COMPLETED_GRACE_MS + 5_000,
+      }).reason,
+    ).toBe('expired')
+  })
+
+  it('the REAL-turn_end backstop variant does NOT re-open the window ' +
+    '(the `durationMs === -1` conditional is load-bearing)', async () => {
+    const supersede = new FlushedTurnSupersedeRegistry()
+    const turn = makeTurn({ capturedText: [ANSWER], realEndObservedAt: 999 } as Partial<CurrentTurn>)
+    const sh = makeStreamDeps({ turn, flushedTurnSupersede: supersede })
+
+    // The turn-end BACKSTOP: the flush fires ON a real turn_end. The session
+    // already stopped, so the window must stay closed (born completed).
+    handleSessionEvent(sh.deps, { kind: 'turn_end', durationMs: 1200 })
+    await settleFlush()
+    expect(sh.delivered).toContain(ANSWER)
+
+    // Unconditionally opening in the flush branch (dropping the -1 check)
+    // nulls this and turns the test red.
+    expect((turn as unknown as { realEndObservedAt: number | null }).realEndObservedAt).not.toBeNull()
+    // The record was born completed (inherited from the atom), so it expires
+    // on the grace, never the 30-minute open cap.
+    expect(
+      supersede.peek(CHAT, undefined, {
+        liveTurnId: turn.turnId,
+        now: Date.now() + SUPERSEDE_COMPLETED_GRACE_MS + 5_000,
+      }).reason,
+    ).toBe('expired')
+  })
+})
+
+// ── LOW #2 (#4167 review) — the two CLOSE PROXIES, which nothing covered ──────
+//
+// `closeFlushCompletionWindows` has three call sites: the real turn_end (pinned
+// by the #4173 block above) and two PROXIES — a new turn minting on the serial
+// session (`case 'enqueue'`), and the main bridge dying (gateway.ts). Both were
+// untested: deleting the `beginTurn` call left all 18 stream-render tests green,
+// and the bridge-death sweep had no coverage at all. A silently-dropped proxy
+// leaves a flushed turn's window OPEN for the full 30-minute crash cap, which is
+// exactly the tail that makes an edit-over of a delivered answer possible.
+describe('#4173 close proxies — a new turn mint and bridge death both close open windows', () => {
+  const settleFlush = () => new Promise((r) => setTimeout(r, 650))
+  const ANSWER =
+    'The composed terminal answer that the model never sent via reply, long enough to be a ' +
+    'genuine substantive flush delivery for the close-proxy wiring tests.'
+  const CLOSED_BY_GRACE = SUPERSEDE_COMPLETED_GRACE_MS + 5_000
+  // Well inside the 30-minute OPEN cap: if the window did NOT close, the record
+  // is still claimable here — which is what makes these assertions bite.
+  const STILL_OPEN_AT = 10 * 60_000
+
+  beforeEach(() => {
+    __resetParkedTurnStartsForTest()
+    flushCompletionTracker.closeAll(Date.now())
+  })
+
+  async function flushWithOpenWindow(supersede: FlushedTurnSupersedeRegistry) {
+    const turn = makeTurn({ capturedText: [ANSWER], realEndObservedAt: 111 } as Partial<CurrentTurn>)
+    const sh = makeStreamDeps({ turn, flushedTurnSupersede: supersede })
+    handleSessionEvent(sh.deps, { kind: 'turn_end', durationMs: -1, reason: 'answer-ready-quiescence' })
+    await settleFlush()
+    expect(sh.delivered).toContain(ANSWER)
+    // Precondition: the window is genuinely OPEN (claimable 10 minutes out).
+    expect((turn as unknown as { realEndObservedAt: number | null }).realEndObservedAt).toBeNull()
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + STILL_OPEN_AT }).reason,
+    ).toBe('supersede')
+    return { turn, sh }
+  }
+
+  it('PROXY A: a NEW TURN minting (case `enqueue`) closes the prior flush window — ' +
+    'the record then expires on the replay grace, not the 30-minute open cap', async () => {
+    const supersede = new FlushedTurnSupersedeRegistry()
+    const { turn, sh } = await flushWithOpenWindow(supersede)
+
+    // The serial session moved on: the CLI enqueues the next turn. The harness's
+    // fake `endCurrentTurnAtomic` does not null the turn, so clear it here — an
+    // idle session is what makes `enqueue` MINT rather than park.
+    ;(sh.deps as unknown as { setCurrentTurn: (t: CurrentTurn | null) => void }).setCurrentTurn(null)
+    handleSessionEvent(sh.deps, {
+      kind: 'enqueue',
+      chatId: CHAT,
+      messageId: null,
+      threadId: null,
+      rawContent: 'the next user message',
+    })
+
+    // The atom is stamped…
+    expect((turn as unknown as { realEndObservedAt: number | null }).realEndObservedAt).not.toBeNull()
+    // …the bounded replay grace still honours the flushed turn's own late reply…
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + 1_000 }).reason,
+    ).toBe('supersede')
+    // …and past the grace it is EXPIRED. Deleting `closeFlushCompletionWindows`
+    // from `beginTurn` turns BOTH of the assertions below red (the record would
+    // still read 'supersede' out to the 30-minute cap).
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + CLOSED_BY_GRACE }).reason,
+    ).toBe('expired')
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + STILL_OPEN_AT }).reason,
+    ).toBe('expired')
+  })
+
+  it('PROXY B: the bridge-death sweep (`closeFlushCompletionWindows`) closes an open ' +
+    'window to the grace and reports how many atoms it stamped', async () => {
+    const supersede = new FlushedTurnSupersedeRegistry()
+    const { turn } = await flushWithOpenWindow(supersede)
+
+    // The main claude bridge disconnected: the exact call gateway.ts makes.
+    const closed = closeFlushCompletionWindows(supersede, Date.now())
+    expect(closed).toBe(1) // the open atom was stamped, not silently skipped
+
+    expect((turn as unknown as { realEndObservedAt: number | null }).realEndObservedAt).not.toBeNull()
+    expect(
+      supersede.peek(CHAT, undefined, { liveTurnId: turn.turnId, now: Date.now() + CLOSED_BY_GRACE }).reason,
+    ).toBe('expired')
+    // Idempotent: a second disconnect sweep stamps nothing further.
+    expect(closeFlushCompletionWindows(supersede, Date.now())).toBe(0)
+  })
+
+  it('PROXY B wiring: gateway.ts calls the sweep on MAIN-bridge disconnect and the ' +
+    '#4176 sub-agent liveness reset alongside it (gateway.ts is not importable)', () => {
+    const src = readFileSync(new URL('../gateway/gateway.ts', import.meta.url), 'utf8')
+    const call = 'const closedWindows = closeFlushCompletionWindows(flushedTurnSupersede, Date.now())'
+    expect(src).toContain(call)
+    // The sweep must sit under the main-bridge guard: a CRON bridge dying says
+    // nothing about the main session's flush windows, so closing there would
+    // shorten a live window on an unrelated session.
+    const idx = src.indexOf(call)
+    expect(idx).toBeGreaterThan(0)
+    const before = src.slice(Math.max(0, idx - 1200), idx)
+    expect(before).toContain('isCronIdentity')
+    // #4176 — the sub-agents die with the session; the reset is co-located.
+    expect(before).toContain('subagentReplyAuthority.reset()')
+  })
+})

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

@@ -25,9 +25,24 @@ OBSERVATION_SCOPE_STRATEGIES = ("curated", "shared", "combined", "off")
 #: 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.
+#:
+#: ``^source:`` (switchroom provenance tagging) is in the list for a different
+#: reason than the other two, and the name of the constant undersells it: what
+#: this list really means is "tags excluded from the CONSOLIDATION SCOPE, kept
+#: on the source fact". ``source:transcript`` is the opposite of volatile — it
+#: is stamped identically on every auto-retain, forever. That is exactly why it
+#: must not reach the scope: a stable tag flips ``curated`` from the bank-wide
+#: ``"shared"`` scope to an explicit ``[["source:transcript"]]`` partition, so
+#: every observation consolidated after the tag ships would be isolated from
+#: every observation consolidated before it. The tag is a RECALL-side filter
+#: handle (``metadata`` is not filterable, tags are), not a consolidation
+#: partition, so scope computation must stay byte-identical to before it
+#: existed. Pinned against ``RETAIN_PROVENANCE_TAG_SCOPE_PATTERN`` in
+#: ``src/memory/hindsight-retain-provenance.ts``.
 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-.+)?$",
+    r"^source:",
 )
 
 DEFAULTS = {

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

@@ -0,0 +1,135 @@
+"""Provenance on auto-retained transcript content (switchroom fix/retain-provenance).
+
+The defect: the Stop-hook auto-retain posts the recent transcript window to
+Hindsight, which extracts facts from it — including from the ASSISTANT's own
+synthesis. Those fabrications land as ordinary memory units and recall back next
+session as though a human had asserted them. Nothing on the stored unit said
+"this came out of a transcript": ``tags`` held only the raw session UUID and the
+only other signal, ``session_id``, lived in ``metadata`` — which Hindsight's
+best-practices page states is NOT filterable, while tags ARE.
+
+The fix stamps a stable, semantic ``source:transcript`` tag via switchroom's
+``retainTags`` default, so recall/reflect can address it (tag filters, tag
+weights). This module asserts the two OUTCOMES that matter at the retain seam:
+
+  1. The tag actually reaches the wire payload, alongside the session tag and
+     any detected lesson tags (i.e. it composes, it does not clobber).
+  2. It does NOT change the observation consolidation scope. This is the
+     non-obvious half: ``observationScopeStrategy: "curated"`` builds the scope
+     from a retain's STABLE tags, so a permanently-stamped tag would flip every
+     bank from the bank-wide ``"shared"`` scope to a ``[["source:transcript"]]``
+     partition, isolating every new observation from every observation
+     consolidated before the tag shipped. ``^source:`` is therefore excluded
+     from the scope in ``DEFAULT_VOLATILE_SCOPE_PATTERNS`` — the tag is a
+     recall-side filter handle, not a consolidation partition.
+
+Stdlib-only; runs under ``python3 -m unittest discover tests/``.
+"""
+
+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 (  # noqa: E402
+    DEFAULTS,
+    DEFAULT_VOLATILE_SCOPE_PATTERNS,
+    compute_observation_scopes,
+)
+from retain import build_retain_payload  # noqa: E402
+
+#: What switchroom's ``renderHindsightSettingsOverrides`` stamps into every
+#: agent's deployed settings.json (src/memory/hindsight-retain-provenance.ts).
+PROVENANCE_TAG = "source:transcript"
+SESSION_ID = "4c386b32-ddfd-40d1-b557-da8135b294af"
+
+
+def _cfg(**over):
+    c = {
+        "retainRoles": ["user", "assistant"],
+        "retainToolCalls": True,
+        "retainContext": "claude-code",
+        "retainMetadata": {},
+        "retainTags": ["{session_id}", PROVENANCE_TAG],
+        "lessonTagging": DEFAULTS["lessonTagging"],
+        "lessonTagMarkers": DEFAULTS["lessonTagMarkers"],
+        "observationScopeStrategy": "curated",
+    }
+    c.update(over)
+    return c
+
+
+def _build(transcript_text="Edited the login handler and ran tests.", **cfg_over):
+    msgs = [
+        {"role": "user", "content": "what did we change?", "uuid": "u1"},
+        {"role": "assistant", "content": transcript_text, "uuid": "a1"},
+    ]
+    built = build_retain_payload(
+        _cfg(**cfg_over),
+        SESSION_ID,
+        msgs,
+        msgs,
+        bank_id="bank",
+        api_url="http://x",
+        api_token=None,
+    )
+    assert built is not None
+    return built["payload"]
+
+
+class ProvenanceTagReachesTheWire(unittest.TestCase):
+    def test_tag_is_on_the_retain_payload(self):
+        self.assertIn(PROVENANCE_TAG, _build()["tags"])
+
+    def test_session_tag_still_templated_and_kept(self):
+        tags = _build()["tags"]
+        self.assertIn(SESSION_ID, tags)
+        self.assertNotIn("{session_id}", tags)
+
+    def test_composes_with_detected_lesson_tags(self):
+        tags = _build("anti-pattern: narrate without executing")["tags"]
+        self.assertIn(PROVENANCE_TAG, tags)
+        self.assertIn("anti-pattern", tags)
+        self.assertIn(SESSION_ID, tags)
+
+    def test_absent_when_retain_tags_config_omits_it(self):
+        # The tag is data, not hardcoded behaviour: retain.py has no knowledge
+        # of it beyond honouring the configured retainTags. That keeps the
+        # vendored plugin generic and the switchroom stamp the single source.
+        tags = _build(retainTags=["{session_id}"])["tags"]
+        self.assertNotIn(PROVENANCE_TAG, tags)
+
+
+class ProvenanceTagIsScopeNeutral(unittest.TestCase):
+    """The tag must not silently re-partition observation consolidation."""
+
+    def test_curated_scope_stays_shared_with_the_provenance_tag(self):
+        payload = _build()
+        self.assertEqual(payload["observation_scopes"], "shared")
+
+    def test_scope_is_byte_identical_to_a_bank_without_the_tag(self):
+        with_tag = _build()["observation_scopes"]
+        without = _build(retainTags=["{session_id}"])["observation_scopes"]
+        self.assertEqual(with_tag, without)
+
+    def test_a_stable_tag_that_is_not_excluded_would_have_changed_the_scope(self):
+        # Guards the guard: proves the "shared" result above is caused by the
+        # exclusion pattern and not by curated ignoring stable tags generally.
+        scope, err = compute_observation_scopes(
+            [SESSION_ID, "project:switchroom"], _cfg()
+        )
+        self.assertIsNone(err)
+        self.assertEqual(scope, [["project:switchroom"]])
+
+    def test_exclusion_pattern_is_present_and_matches_the_tag(self):
+        self.assertIn(r"^source:", DEFAULT_VOLATILE_SCOPE_PATTERNS)
+        scope, err = compute_observation_scopes([SESSION_ID, PROVENANCE_TAG], _cfg())
+        self.assertIsNone(err)
+        self.assertEqual(scope, "shared")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    unittest.main()

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, once this session is forgotten.\n\nDURABILITY GATE. Emit a candidate ONLY if it is one of these five classes:\n- PREFERENCE — what the user likes, wants, or always does; a standing rule or correction.\n- DECISION — a settled choice that changes how future work is done, including a choice NOT to do something. A decision about the mechanics of the CURRENT task (which worker to dispatch, which branch to rebase, which PR to merge now, what to do next) is process narration, not a durable decision — drop it unless it establishes a standing rule or permanently changes a system.\n- FINDING — a root cause, a measurement, or verified behaviour of a system. Include the number.\n- OUTCOME — a completed result that changed the world: what shipped, what a thing turned out to be. Not the act of shipping it.\n- RELATIONSHIP — who a person is, what a project or tool is, and how they connect.\nIf a candidate fits none of the five, it is not a memory. Drop it; do not reword it into one.\n\nA 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- The act of delegating, dispatching, spawning, launching, steering or merging\n  work — including when it succeeded. \"X was dispatched and completed\" is the\n  session describing itself. Record only what the work LEARNED or CHANGED.\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\nWrite each fact so it stands alone: name the thing, the number, and the date. A\nsentence that only makes sense while reading this transcript is not durable.\n\nIf a candidate fact matches an exclusion, drop it rather than rewording it. If\nnothing durable remains, return an empty facts list.\n",
+  "retainMission": "Extract durable facts that will still be true and useful weeks from now, once this session is forgotten.\n\nDURABILITY GATE. Emit a candidate ONLY if it is one of these five classes:\n- PREFERENCE — what the user likes, wants, or always does; a standing rule or correction.\n- DECISION — a settled choice that changes how future work is done, including a choice NOT to do something. A decision about the mechanics of the CURRENT task (which worker to dispatch, which branch to rebase, which PR to merge now, what to do next) is process narration, not a durable decision — drop it unless it establishes a standing rule or permanently changes a system.\n- FINDING — a root cause, a measurement, or verified behaviour of a system. Include the number.\n- OUTCOME — a completed result that changed the world: what shipped, what a thing turned out to be. Not the act of shipping it.\n- RELATIONSHIP — who a person is, what a project or tool is, and how they connect.\nIf a candidate fits none of the five, it is not a memory. Drop it; do not reword it into one.\n\nA 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- The act of delegating, dispatching, spawning, launching, steering or merging\n  work — including when it succeeded. \"X was dispatched and completed\" is the\n  session describing itself. Record only what the work LEARNED or CHANGED.\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- The assistant's own answers, summaries, recaps, or reflect output. Before\n  extracting, ask: does anything in this transcript support this claim OTHER\n  than the assistant having asserted it? If not, drop it — a model's own\n  synthesis re-extracted as a fact is how a guess becomes permanent.\n  Concretely, never produce a fact whose only support is the assistant\n  stating a date, a version, an attribution, a total, or a decision that the\n  user never confirmed and no tool output shows. An unverified claim recalls\n  later as though it had been established, which is worse than not\n  remembering it at all.\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\nWrite each fact so it stands alone: name the thing, the number, and the date. A\nsentence that only makes sense while reading this transcript is not durable.\n\nIf a candidate fact matches an exclusion, drop it rather than rewording it. If\nnothing durable remains, return an empty facts list.\n",
   "autoRecall": true,
   "autoRetain": true,
   "retainMode": "full-session",