switchroom 0.17.0 → 0.17.1

package/telegram-plugin/gateway/approvals-commands.ts

@@ -13,7 +13,7 @@
  * add on top of the same client. Tracked in the migration TODO inline.
  */
 
-import { escapeMarkdown, codeSpanSafe } from '../format.js';
+import { escapeMarkdown, codeSpanSafe, hardenCardBreaks } from '../format.js';
 import type { Bot, Context } from "grammy";
 import { richMessage } from "../rich-send.js";
 import {
@@ -84,7 +84,11 @@ export function registerApprovalsCommands(
           );
         })
         .join("\n");
-      await ctx.replyWithRichMessage(richMessage(`**Active approvals**\n\n${summary}\n\n${detail}`));
+      // hardenCardBreaks: the per-agent `summary` rows and per-decision
+      // `detail` rows are single-`\n`-joined field lines that would soft-
+      // collapse into one blob under the GFM rich renderer. Harden them into
+      // GFM hard breaks (block gaps between the three sections preserved).
+      await ctx.replyWithRichMessage(richMessage(hardenCardBreaks(`**Active approvals**\n\n${summary}\n\n${detail}`)));
       return;
     }
 

package/telegram-plugin/gateway/gateway.ts

@@ -233,7 +233,7 @@ const REPLY_TO_TEXT_MAX = 200
 const SILENT_END_FALLBACK_TEXT =
   '⚠️ The agent finished working but didn’t send a reply — your last ' +
   'message may not have been answered. Please try asking again.'
-import { splitMarkdownChunks, hardSliceToCap, repairEscapedWhitespace, normalizeParagraphBreaks, addParagraphSpacers, normalizePunctuation, stripExcessBold, escapeMarkdown, RICH_MESSAGE_MAX_CHARS } from '../format.js'
+import { splitMarkdownChunks, hardSliceToCap, repairEscapedWhitespace, normalizeParagraphBreaks, addParagraphSpacers, normalizePunctuation, stripExcessBold, escapeMarkdown, hardenCardBreaks, RICH_MESSAGE_MAX_CHARS } from '../format.js'
 import { richMessage } from '../rich-send.js'
 import { scrubVoice } from '../text-voice-scrub.js'
 import {
@@ -10812,7 +10812,10 @@ function renderVaultRequestSaveCard(req: PendingVaultRequestSave, agentSlug: str
   }
   lines.push('')
   lines.push(`_Tap Save to write to the host vault, Rename to change the key name, or Discard to drop it. The value is held in this chat's gateway memory until you decide._`)
-  return lines.join('\n')
+  // hardenCardBreaks: labelled field lines (key: / why:) would soft-collapse
+  // into one blob under the GFM rich renderer; this card is sent direct via
+  // richMessage, bypassing the switchroomReply chokepoint.
+  return hardenCardBreaks(lines.join('\n'))
 }
 
 /**
@@ -11313,6 +11316,8 @@ async function executeVaultRequestAccess(args: Record<string, unknown>): Promise
   pendingVaultRequestAccesses.set(stageId, pending)
   sweepPendingVaultRequestAccesses()
 
+  // renderVaultRequestAccessCard self-hardens its field line breaks (this card
+  // is sent direct, bypassing the switchroomReply chokepoint).
   const text = renderVaultRequestAccessCard(pending)
   const threadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
   // Remember the agent's working topic so the grant-outcome inbound resumes in it.
@@ -15717,8 +15722,17 @@ async function switchroomReply(
   }
   // #2669: `options.html` now means "render `text` as GFM markdown via the
   // rich-message path" (legacy field name kept). Plain otherwise.
+  //
+  // Every deterministic slash-command card ships through this html branch as
+  // RAW markdown (no reply-path normalization). Under the Bot API 10.1 GFM
+  // renderer a lone `\n` is a SOFT break, so a card whose builder stacks
+  // labelled fields with single `\n` (e.g. `/usage`, `/model`, `/auth`)
+  // renders as one run-on blob. `hardenCardBreaks` promotes those lone
+  // field breaks to GFM hard breaks (`  \n`) while leaving lists / tables /
+  // fenced code / blockquotes / headings on their native single `\n` — the
+  // same treatment the direct-send cards get from `stackCardLines`.
   if (options.html) {
-    await ctx.replyWithRichMessage(richMessage(text), replyOpts)
+    await ctx.replyWithRichMessage(richMessage(hardenCardBreaks(text)), replyOpts)
   } else {
     await ctx.reply(text, replyOpts)
   }

package/telegram-plugin/gateway/ms365-write-approval.test.ts

@@ -105,6 +105,19 @@ describe("buildMs365CardText", () => {
     expect(text).toContain("bob@example.com");
   });
 
+  it("hard-breaks its field lines so GFM doesn't collapse them into a blob", () => {
+    // The Agent:/Tool:/Item:/Account: field lines must carry GFM hard breaks
+    // (`  \n`), not bare `\n` soft breaks. Assert every adjacent pair of
+    // non-blank content lines is separated by a hard break or a `\n\n` gap.
+    const text = buildMs365CardText(base);
+    expect(text).toContain("  \n");
+    const nl = text.split("\n");
+    for (let i = 0; i < nl.length - 1; i++) {
+      if (nl[i].trim() === "" || nl[i + 1].trim() === "") continue; // block gap
+      expect(nl[i].endsWith("  ")).toBe(true);
+    }
+  });
+
   it("omits ID line for new files", () => {
     const text = buildMs365CardText({ ...base, itemId: "(new)" });
     expect(text).not.toMatch(/^ID:/m);

package/telegram-plugin/gateway/ms365-write-approval.ts

@@ -31,6 +31,7 @@
 
 import type { IpcClient } from "./ipc-server.js";
 import type { RequestMs365ApprovalMessage } from "./ipc-protocol.js";
+import { hardenCardBreaks } from "../format.js";
 
 // ────────────────────────────────────────────────────────────────────────
 // Wire shape — validates an inbound preview payload
@@ -188,7 +189,10 @@ export function buildMs365CardText(p: Ms365WritePreview): string {
   lines.push(
     "⚠️ Weak attestation (RFC §8 v1): operator should click through to verify the actual change before approving. Structural diff coming v1.5.",
   );
-  return lines.join("\n");
+  // hardenCardBreaks: labelled field lines (Agent:/Tool:/Item:/Account:/Size:…)
+  // would soft-collapse into one blob under the GFM rich renderer; this card is
+  // posted direct (not via the switchroomReply chokepoint).
+  return hardenCardBreaks(lines.join("\n"));
 }
 
 function truncate(s: string, n: number): string {

package/telegram-plugin/gateway/vault-request-access-card.ts

@@ -20,6 +20,7 @@
 
 import { escapeHtmlForTg } from '../shared/bot-runtime.js'
 import { codeSpanSafe } from './approval-card.js'
+import { hardenCardBreaks } from '../format.js'
 
 /** Minimal shape the card needs — a subset of PendingVaultRequestAccess. */
 export interface VaultRequestAccessCardInput {
@@ -57,5 +58,8 @@ export function renderVaultRequestAccessCard(
   lines.push(
     `_Tap Approve to mint a scoped grant token (same flow as \`switchroom vault grant\`). Tap Deny to refuse — the agent will receive a denial result._`,
   )
-  return lines.join('\n')
+  // hardenCardBreaks: the labelled field lines (key: / scope:…/ why:) would
+  // soft-collapse into one blob under the GFM rich renderer; this card is sent
+  // direct via richMessage, bypassing the switchroomReply chokepoint.
+  return hardenCardBreaks(lines.join('\n'))
 }

package/telegram-plugin/tests/format-consistency.test.ts

@@ -16,11 +16,90 @@ import {
   normalizePunctuation,
   stripExcessBold,
   splitMarkdownChunks,
+  hardenCardBreaks,
   PARAGRAPH_SPACER,
 } from '../format.js'
 
 const SP = PARAGRAPH_SPACER // U+00A0
 
+describe('hardenCardBreaks — deterministic card line-break hardener', () => {
+  test('promotes lone field breaks to GFM hard breaks (the blob fix)', () => {
+    const out = hardenCardBreaks('Agent: assistant\nAuth: Max\nStatus: running')
+    expect(out).toBe('Agent: assistant  \nAuth: Max  \nStatus: running')
+  })
+
+  test('preserves `\\n\\n` block gaps (not promoted)', () => {
+    const out = hardenCardBreaks('**Header**\nfield one\n\n**Next**\nfield two')
+    expect(out).toBe('**Header**  \nfield one\n\n**Next**  \nfield two')
+  })
+
+  test('leaves GFM list items on their native single `\\n`', () => {
+    const out = hardenCardBreaks('- one\n- two\n- three')
+    expect(out).toBe('- one\n- two\n- three')
+  })
+
+  test('leaves GFM table rows untouched', () => {
+    const src = '| a | b |\n| - | - |\n| 1 | 2 |'
+    expect(hardenCardBreaks(src)).toBe(src)
+  })
+
+  test('never touches a fenced code block interior', () => {
+    const src = '**Accounts**\n```\nalice  ok\nbob    ok\n```\n**Agents**'
+    // The fenced monospace table keeps its single `\n`s; the header lines that
+    // face the fence are not hard-broken (fence line is a block construct).
+    expect(hardenCardBreaks(src)).toBe(src)
+  })
+
+  test('does not hard-break across a heading or blockquote', () => {
+    expect(hardenCardBreaks('# Title\nbody')).toBe('# Title\nbody')
+    expect(hardenCardBreaks('> quote\nbody')).toBe('> quote\nbody')
+  })
+
+  test('collapses 3+ newline runs to a single `\\n\\n` gap', () => {
+    expect(hardenCardBreaks('a\n\n\n\nb')).toBe('a\n\nb')
+  })
+
+  test('is idempotent', () => {
+    const src = 'Agent: x\nAuth: y\n\n**H**\n🟢 Broker running\n🟢 Kernel up'
+    const once = hardenCardBreaks(src)
+    expect(hardenCardBreaks(once)).toBe(once)
+  })
+
+  test('no-op for single-line text', () => {
+    expect(hardenCardBreaks('just one line')).toBe('just one line')
+  })
+
+  // Regression (reviewer nit): a field line that STARTS with an inline code
+  // span used to be misclassified as a masked fenced-block open (fenced +
+  // inline masks shared one placeholder prefix), so its lone `\n` was never
+  // hardened and the card collapsed. Real victim: `/vault get` rendering
+  // `` `key` = `value` `` on one line.
+  test('hardens a line that STARTS with an inline code span', () => {
+    const out = hardenCardBreaks('`key` = `value`\n`k2` = `v2`')
+    expect(out).toBe('`key` = `value`  \n`k2` = `v2`')
+  })
+
+  test('/vault get shape (`key` =\\n`value`) hard-breaks onto two lines', () => {
+    const out = hardenCardBreaks('`sk-key` =\n`hunter2`')
+    expect(out).toBe('`sk-key` =  \n`hunter2`')
+  })
+
+  test('inline-span-leading fix does NOT disturb a real fenced block', () => {
+    // A genuine ``` fence between two inline-span-leading field lines: the
+    // field lines harden, the fence interior stays byte-for-byte intact.
+    const src = '`a` = 1\n```\nx = 1\ny = 2\n```\n`b` = 2'
+    const out = hardenCardBreaks(src)
+    expect(out).toContain('```\nx = 1\ny = 2\n```') // fence interior untouched
+    expect(out).not.toContain('x = 1  \n') // no hard break injected inside fence
+  })
+
+  test('mid-line inline spans still harden (unchanged behaviour)', () => {
+    expect(hardenCardBreaks('Model: `opus`\nAuth: `Max`')).toBe(
+      'Model: `opus`  \nAuth: `Max`',
+    )
+  })
+})
+
 describe('addParagraphSpacers — uniform block spacing', () => {
   test('still spaces prose→prose (existing behaviour)', () => {
     const out = addParagraphSpacers('Alpha.\n\nBravo.')

package/telegram-plugin/tests/vault-request-access-card.test.ts

@@ -91,4 +91,21 @@ describe('renderVaultRequestAccessCard', () => {
     })
     expect(text).toContain('why: _not provided_')
   })
+
+  it('hard-breaks its field lines so GFM does not collapse the card into a blob', () => {
+    const text = renderVaultRequestAccessCard({
+      agent: 'overlord',
+      key: 'openai/OPENAI_API_KEY',
+      scope: 'read',
+      reason: 'call the completions endpoint',
+      ttl_seconds: 7 * 86400,
+    })
+    // The key: / scope: / why: field lines carry GFM hard breaks (`  \n`).
+    expect(text).toContain('  \n')
+    const nl = text.split('\n')
+    for (let i = 0; i < nl.length - 1; i++) {
+      if (nl[i].trim() === '' || nl[i + 1].trim() === '') continue // `\n\n` block gap
+      expect(nl[i].endsWith('  ')).toBe(true)
+    }
+  })
 })

package/telegram-plugin/tests/welcome-text.test.ts

@@ -343,6 +343,70 @@ describe("statusPairedText", () => {
   });
 });
 
+// Regression: the Bot API 10.1 rich-message (GFM) renderer collapses a LONE
+// `\n` between two non-blank lines into a SPACE (soft break), so a card built
+// with `lines.join("\n")` renders as one run-on blob. The deterministic card
+// builders MUST route through `stackCardLines`, which promotes every inter-
+// field break to a GFM hard break (`  \n`) and keeps intentional `\n\n` block
+// gaps. These tests pin that so the "/status renders as a giant run-on blob"
+// bug can't silently regress.
+describe("card line-break hardening (GFM soft-break blob fix)", () => {
+  const meta: AgentMetadata = {
+    ...baseMeta,
+    agentName: "assistant",
+    model: "sonnet",
+    status: "running",
+    uptime: "3h",
+    auth: { authenticated: true, subscription_type: "Max", expires_in: "29 days", auth_source: "oauth" },
+    live: [
+      { status: "ok", label: "Broker", detail: "running" },
+      { status: "ok", label: "Kernel", detail: "up" },
+    ],
+    audit: {
+      version: "v0.3.0",
+      tools: "all",
+      skills: "git, vault",
+      limits: "idle 30m",
+      channel: "switchroom",
+      memoryBank: "assistant",
+    },
+  };
+
+  // Every adjacent field-pair inside a block is separated by a GFM hard break,
+  // and NO two adjacent non-blank content lines are joined by a bare `\n`
+  // (which would soft-collapse into a blob). Block separators stay `\n\n`.
+  const assertNoSoftJoin = (out: string) => {
+    const nl = out.split("\n");
+    for (let i = 0; i < nl.length - 1; i++) {
+      const cur = nl[i];
+      const next = nl[i + 1];
+      if (cur.trim() === "" || next.trim() === "") continue; // `\n\n` block gap
+      // A hardened line ends in the two-space GFM hard-break marker.
+      expect(cur.endsWith("  ")).toBe(true);
+    }
+  };
+
+  it("/status: fields are hard-broken, not soft-collapsed into a blob", () => {
+    const out = statusPairedText({ user: "@ken", meta });
+    // Adjacent fields inside the identity block use a GFM hard break.
+    expect(out).toContain("Auth: ✓ Max · expires 29 days  \n");
+    // Health rows stack (hard break before each 🟢 row).
+    expect(out).toContain("  \n🟢 **Kernel**");
+    // Audit rows stack.
+    expect(out).toContain("**Version** v0.3.0  \n");
+    // Blocks stay separated by a real paragraph gap.
+    expect(out).toContain("\n\n**Health**");
+    assertNoSoftJoin(out);
+  });
+
+  it("/start, /help, /commands, /status-pending all hard-break their lines", () => {
+    assertNoSoftJoin(startText("assistant", false));
+    assertNoSoftJoin(helpText("assistant"));
+    assertNoSoftJoin(switchroomHelpText("assistant"));
+    assertNoSoftJoin(statusPendingText("abc-123"));
+  });
+});
+
 // Local alias for the audit shape — duplicates the AgentMetadata.audit
 // type so the test file doesn't have to re-import it just for one
 // hostile-input fixture.

package/telegram-plugin/welcome-text.ts

@@ -13,7 +13,7 @@
  */
 
 import { maskUsername } from "./demo-mask.js";
-import { escapeMarkdown } from "./card-format.js";
+import { escapeMarkdown, stackCardLines } from "./card-format.js";
 
 export type AuthSummary = {
   authenticated: boolean;
@@ -148,7 +148,7 @@ export function formatAgentLine(meta: AgentMetadata): string {
  */
 export function startText(agentName: string, dmDisabled: boolean): string {
   if (dmDisabled) return "This bot isn't accepting new connections.";
-  return [
+  return stackCardLines([
     `**Switchroom** — Telegram on your Claude Pro or Max subscription.`,
     ``,
     `This bot is the **${escapeHtml(agentName)}** agent. Pair first, then send messages here and they reach the agent; replies and reactions come back.`,
@@ -158,7 +158,7 @@ export function startText(agentName: string, dmDisabled: boolean): string {
     `2. In Claude Code: \`/telegram:access pair <code>\``,
     ``,
     `After pairing, try \`/status\` or \`/commands\`.`,
-  ].join("\n");
+  ]);
 }
 
 /**
@@ -166,7 +166,7 @@ export function startText(agentName: string, dmDisabled: boolean): string {
  * Deliberately short because Telegram truncates /help popovers.
  */
 export function helpText(agentName: string): string {
-  return [
+  return stackCardLines([
     `**Switchroom** — your Pro/Max subscription, wired to Telegram.`,
     ``,
     `This bot is the **${escapeHtml(agentName)}** agent. Text and photos route through to it; replies, reactions and progress cards come back.`,
@@ -177,7 +177,7 @@ export function helpText(agentName: string): string {
     `\`/status\` — agent, model, auth`,
     `\`/vault audit <agent>\` — admin: review agent's vault access + one-tap [🔓 Allow] on recent denials`,
     `\`/commands\` — full command list`,
-  ].join("\n");
+  ]);
 }
 
 /**
@@ -246,14 +246,18 @@ export function statusPairedText(params: {
     if (audit.memoryBank) lines.push(`**Memory** ${escapeHtml(audit.memoryBank)}`);
   }
 
-  return lines.join("\n");
+  return stackCardLines(lines);
 }
 
 /**
  * `/status` when the sender isn't paired yet but has a pending code.
  */
 export function statusPendingText(code: string): string {
-  return `Pending pairing — run in Claude Code:\n\n\`/telegram:access pair ${code}\``;
+  return stackCardLines([
+    `Pending pairing — run in Claude Code:`,
+    ``,
+    `\`/telegram:access pair ${code}\``,
+  ]);
 }
 
 /**
@@ -365,7 +369,7 @@ export const TELEGRAM_BASE_COMMANDS = TELEGRAM_MENU_COMMANDS.slice(0, 3);
 export const TELEGRAM_SWITCHROOM_COMMANDS = TELEGRAM_MENU_COMMANDS.slice(3);
 
 export function switchroomHelpText(agentName: string): string {
-  return [
+  return stackCardLines([
     `**Switchroom bot** — commands for the **${escapeHtml(agentName)}** agent.`,
     ``,
     `**Session & approvals**`,
@@ -415,7 +419,7 @@ export function switchroomHelpText(agentName: string): string {
     `\`/commands\` — this help`,
     ``,
     `_Tip: \`/update\` shows the plan; \`/update apply\` executes it; \`/restart\` bounces a stuck agent; \`/version\` checks what's running._`,
-  ].join("\n");
+  ]);
 }
 
 /**

package/vendor/hindsight-memory/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+### Changed (switchroom divergence)
+
+- **retain.py: decouple chunked window-slicing from the `retainEveryNTurns > 1`
+  throttle** (switchroom Phase 6b). Previously the chunked sliding-window only
+  applied when `retainEveryNTurns > 1`; with `retainEveryNTurns=1` (switchroom
+  sets this in `scaffold.ts` for every-turn crash durability) chunked mode fell
+  through to full-session and re-consolidated the entire accumulated transcript
+  on every Stop fire. Window selection is now extracted into a pure
+  `select_retain_window()` helper and slices a window of
+  `max(retainEveryNTurns, 1) + retainOverlapTurns` turns whenever
+  `retainMode == "chunked"`, independent of the throttle. The throttle-skip
+  logic (`retain_every_n > 1` firing cadence) is unchanged, so `> 1` behaviour
+  and the full-session default are equivalent. This is a deliberate switchroom
+  divergence from pristine vendor and is a **candidate to upstream to
+  vectorize-io/hindsight** — decoupling *what* to retain from *whether* to fire
+  this turn is a general improvement, not switchroom-specific.
+
+- **content.py: `slice_last_turns_by_user_boundary()` counts genuine HUMAN
+  turns only** (switchroom Phase 6b, adversarial-review fix). Claude Code emits
+  tool results as `role="user"` messages whose content is a list of
+  `tool_result` blocks. The boundary counter treated every `role="user"`
+  message as a turn, so on a tool-heavy turn (≥N sequential tool rounds) a
+  fixed-size retain window filled with `tool_result` messages and pushed the
+  actual human message OUTSIDE the window — silently dropping the fact from
+  that fire and every later fire (whose window starts even further away), so it
+  was never retained; on restart the fact was gone. A message whose content is
+  entirely `tool_result` blocks is now skipped as a boundary
+  (`_is_tool_result_only_user_message`), so "window = N turns" means N *human*
+  turns regardless of tool volume. Affects both the retain window-slice and the
+  recall context-slice (both want N human turns). **Candidate to upstream** —
+  the same silent-loss bug exists in vendor's own `retainEveryNTurns > 1`
+  chunked path. NOTE: switchroom never ran chunked before Phase 6b, so this
+  changes no previously-exercised switchroom behaviour.
+
+- **retain.py: SessionEnd `force=True` widens chunked mode to a full-session
+  sweep** (switchroom Phase 6b, belt-and-braces). Per-turn fires still slice
+  the window; the single forced retain at SessionEnd
+  (`session_end.py` → `run_retain(force=True)`) now retains the whole session
+  in chunked mode, guaranteeing a graceful shutdown always flushes everything
+  even if per-turn windowing had an edge. Costs one full sweep per session (at
+  end), not per turn.
+
 ### Ported from upstream (vectorize-io/hindsight, `hindsight-integrations/claude-code/`)
 
 - `c5a61db2b` — raise `_check_health` default timeout 2s→10s in

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

@@ -167,13 +167,48 @@ def truncate_recall_query(query: str, latest_query: str, max_chars: int) -> str:
 # ---------------------------------------------------------------------------
 
 
+def _is_tool_result_only_user_message(message: dict) -> bool:
+    """True when a ``role="user"`` message carries ONLY tool_result blocks.
+
+    SWITCHROOM DIVERGENCE (candidate to upstream to vectorize-io/hindsight):
+    Claude Code emits tool results as ``role="user"`` messages whose content
+    is a list of ``{"type": "tool_result", ...}`` blocks — they are NOT
+    human turns. A genuine human turn has text (a string, or a content list
+    with at least one non-tool_result block, e.g. ``{"type": "text"}`` or an
+    image). Treating tool_result messages as turn boundaries lets a tool-heavy
+    turn (≥N sequential tool rounds) fill a fixed-size retain window with
+    tool_result messages and push the actual human message OUTSIDE the window
+    — silently dropping the fact from that fire, and from every later fire
+    (whose window starts even further from the human message). On restart the
+    fact is gone. This helper lets the boundary counter skip those messages so
+    "window = N turns" means N *human* turns regardless of tool volume.
+    """
+    if message.get("role") != "user":
+        return False
+    content = message.get("content")
+    if isinstance(content, list):
+        blocks = [b for b in content if isinstance(b, dict)]
+        # A non-empty content list that is ENTIRELY tool_result blocks.
+        if blocks and all(b.get("type") == "tool_result" for b in blocks):
+            return True
+    return False
+
+
 def slice_last_turns_by_user_boundary(messages: list, turns: int) -> list:
     """Slice messages to the last N turns, where a turn starts at a user message.
 
     Port of: sliceLastTurnsByUserBoundary() in index.js
 
-    Walks backward counting user messages as turn boundaries. Returns
-    messages from the Nth user boundary to the end.
+    Walks backward counting GENUINE HUMAN user messages as turn boundaries.
+    Returns messages from the Nth human boundary to the end.
+
+    SWITCHROOM DIVERGENCE (candidate to upstream): tool_result messages carry
+    ``role="user"`` in the Claude Code transcript but are not human turns; they
+    are skipped as boundaries (see ``_is_tool_result_only_user_message``). This
+    keeps the fixed-size retain window anchored to human turns so a tool-heavy
+    turn can never push the human's fact outside the window (silent memory loss).
+    Affects both the retain window-slice and the recall context slice — both
+    want "N human turns", not "N transcript user-messages".
     """
     if not isinstance(messages, list) or not messages or turns <= 0:
         return []
@@ -182,7 +217,8 @@ def slice_last_turns_by_user_boundary(messages: list, turns: int) -> list:
     start_index = -1
 
     for i in range(len(messages) - 1, -1, -1):
-        if messages[i].get("role") == "user":
+        msg = messages[i]
+        if msg.get("role") == "user" and not _is_tool_result_only_user_message(msg):
             user_turns_seen += 1
             if user_turns_seen >= turns:
                 start_index = i

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

@@ -69,6 +69,60 @@ def read_transcript(transcript_path: str) -> list:
     return messages
 
 
+def select_retain_window(
+    retain_mode: str,
+    retain_every_n: int,
+    overlap_turns: int,
+    all_messages: list,
+    force: bool = False,
+) -> tuple:
+    """Decide which messages to retain and whether to send as a full window.
+
+    Returns ``(messages_to_retain, retain_full_window)``.
+
+    SWITCHROOM DIVERGENCE (Phase 6b — candidate to upstream to
+    vectorize-io/hindsight): the chunked sliding-window is decoupled from
+    the ``retainEveryNTurns > 1`` throttle. Upstream only sliced a window
+    when ``retain_every_n > 1``; with ``retainEveryNTurns=1`` (switchroom's
+    every-turn crash-durability setting, applied in scaffold.ts) chunked
+    mode fell through to full-session and re-consolidated the ENTIRE
+    accumulated transcript on every Stop fire — an unbounded, per-turn cost.
+
+    Decoupling is safe because window selection and the throttle answer two
+    independent questions: the throttle decides *whether* to fire this turn
+    (still owned by run_retain, unchanged); this function only decides *what*
+    to retain once a fire happens. A chunked window of
+    ``max(retain_every_n, 1) + overlap_turns`` turns is correct for any
+    ``retain_every_n >= 1``. With ``retain_every_n=1, overlap=2`` the window
+    is the 3 most-recent HUMAN turns (tool_result messages don't count as
+    turns — see slice_last_turns_by_user_boundary).
+
+    ``force=True`` (SessionEnd final retain) widens chunked mode to a
+    full-session sweep — belt-and-braces so a graceful shutdown always flushes
+    the whole session even if per-turn windowing had an edge. This costs a
+    full sweep only ONCE per session (at end), not per turn.
+
+    Durability invariant (jtbd-memory-survives-restart UAT): the window
+    always extends to the END of the transcript (``slice_last_turns_by_user_boundary``
+    returns ``messages[start:]``), so the turn that just completed — the one
+    whose Stop hook is firing — is ALWAYS included. Every turn fires (no
+    throttle at n=1), so every turn's content is retained on its own fire.
+    Boundaries are counted on human messages only, so a tool-heavy turn can't
+    push the human's fact outside the window. No fact can fall outside every
+    window.
+    """
+    if retain_mode == "chunked" and not force:
+        # Sliding window: N turns + configured overlap. max(retain_every_n, 1)
+        # keeps the window valid at n=1 (the decoupling); for n>1 this equals
+        # the previous `retain_every_n + overlap_turns` (behaviour unchanged).
+        window_turns = max(retain_every_n, 1) + overlap_turns
+        messages_to_retain = slice_last_turns_by_user_boundary(all_messages, window_turns)
+        return messages_to_retain, True
+    # Full session: vendor full-session mode, OR a forced (SessionEnd) chunked
+    # sweep. Retain all messages, always as a full window.
+    return list(all_messages), True
+
+
 def run_retain(hook_input: dict, force: bool = False) -> dict:
     """Run the auto-retain flow.
 
@@ -104,7 +158,8 @@ def run_retain(hook_input: dict, force: bool = False) -> dict:
 
     debug_log(config, f"Read {len(all_messages)} messages from transcript")
 
-    # Retention mode: full session (default) or chunked (legacy)
+    # Retention mode: full session (vendor default) or chunked. Switchroom
+    # runs chunked at retainEveryNTurns=1 (see select_retain_window / scaffold.ts).
     retain_mode = config.get("retainMode", "full-session")
     retain_every_n = max(1, config.get("retainEveryNTurns", 1))
     retain_full_window = False
@@ -118,19 +173,25 @@ def run_retain(hook_input: dict, force: bool = False) -> dict:
             debug_log(config, f"Turn {turn_count}/{retain_every_n}, skipping retain (next at turn {next_at})")
             return {"status": "skipped", "reason": "throttled"}
 
-    if retain_mode == "chunked" and retain_every_n > 1:
-        # Sliding window: N turns + configured overlap
-        overlap_turns = config.get("retainOverlapTurns", 0)
-        window_turns = retain_every_n + overlap_turns
-        messages_to_retain = slice_last_turns_by_user_boundary(all_messages, window_turns)
-        retain_full_window = True
+    # Window selection is decoupled from the throttle above — see
+    # select_retain_window() for the switchroom-divergence rationale
+    # (Phase 6b: chunked window-slicing now works at retainEveryNTurns=1).
+    overlap_turns = config.get("retainOverlapTurns", 0)
+    messages_to_retain, retain_full_window = select_retain_window(
+        retain_mode, retain_every_n, overlap_turns, all_messages, force=force
+    )
+    if retain_mode == "chunked" and not force:
+        window_turns = max(retain_every_n, 1) + overlap_turns
+        debug_log(
+            config,
+            f"Chunked retain firing (window: {window_turns} human turns, {len(messages_to_retain)} messages)",
+        )
+    elif retain_mode == "chunked" and force:
         debug_log(
             config,
-            f"Chunked retain firing (window: {window_turns} turns, {len(messages_to_retain)} messages)",
+            f"Chunked retain, forced full-session sweep (SessionEnd): {len(all_messages)} messages",
         )
     else:
-        # Full session mode: retain all messages, always as full window
-        retain_full_window = True
         debug_log(config, f"Full session retain: {len(all_messages)} messages")
 
     # Format transcript