switchroom 0.19.26 → 0.19.27

package/telegram-plugin/uat/assertions.ts

@@ -23,8 +23,15 @@ import type { Driver, ObservedMessage, ObservedReaction } from "./driver.js";
  *
  * Single source of truth; the worker-feed scenario asserts against this,
  * and recall/reply scenarios exclude it via {@link isWorkerFeedMessage}.
+ *
+ * `Workers?` is load-bearing, not cosmetic: the COMBINED (2+ worker) card's
+ * glance line reads `🛠 WORKERS · N running · …`, and `Worker\b` cannot match
+ * inside `WORKERS` (no word boundary between `r` and `S`). Without the optional
+ * `s` the whole 2+ worker surface was invisible to this predicate, so a
+ * recall/reply scenario running with two live workers could latch onto the
+ * combined card as the agent's answer. Found during the #3842 card audit.
  */
-export const WORKER_FEED_RE = /🛠[️]?\s*Worker\b|finished\s*·\s*(?:completed|failed)/i;
+export const WORKER_FEED_RE = /🛠[️]?\s*Workers?\b|finished\s*·\s*(?:completed|failed)/i;
 
 /**
  * True when `m` is a worker-activity-feed message rather than the agent's
@@ -74,22 +81,26 @@ const ACTIVITY_BODY_LINE_RE = /^[→✓↳]/u;
 const LIVENESS_HEADER_L1_RE = /^(?:🤖|🛠[️]?|⚙[️]?)\s+\S/u;
 
 /**
- * Leading chrome a SUBORDINATE (worker) card carries since #3820: the `└─ `
- * header prefix on line 1 and a `U+2800` indent run on every later line, which
- * together make the worker card readable as a child of the 🤖 agent card.
+ * Leading indent chrome a card line can carry: a `U+2800` run, applied by
+ * `WORKER_STEP_INDENT` to the step lines under each worker header on the
+ * combined (2+ worker) card so one worker's steps are visibly separated from
+ * the next worker's.
  *
  * Every line-shape matcher below must normalise it away first: Telegram
- * delivers both verbatim, and NEITHER is stripped by `String.trim()` — U+2800
- * is category So, not whitespace (that property is exactly why it survives
+ * delivers it verbatim and `String.trim()` does NOT remove it — U+2800 is
+ * category So, not whitespace (that property is exactly why it survives
  * Telegram's own left-trim; see WORKER_STEP_INDENT). Without this, a worker
- * card's header stops matching `LIVENESS_HEADER_L1_RE` and its body lines stop
- * matching `ACTIVITY_BODY_LINE_RE`.
+ * card's body lines stop matching `ACTIVITY_BODY_LINE_RE`.
+ *
+ * #3842 removed the whole-card `└─ ` header prefix and the whole-card indent
+ * that #3820/#3821 put on worker cards, so this no longer has to strip a `└─ `.
+ * The step indent is the only nesting a card emits now.
  */
-const SUBORDINATE_CARD_PREFIX_RE = /^(?:└─\s*|\u2800+)+/u;
+const CARD_INDENT_PREFIX_RE = /^\u2800+/u;
 
-/** A card line with its subordinate-card nesting chrome removed, trimmed. */
+/** A card line with its leading step-indent chrome removed, trimmed. */
 export function stripCardNesting(line: string): string {
-  return line.replace(SUBORDINATE_CARD_PREFIX_RE, "").trim();
+  return line.replace(CARD_INDENT_PREFIX_RE, "").trim();
 }
 const LIVENESS_ELAPSED = String.raw`(?:\d+m)?\d+s`;
 const LIVENESS_HEADER_L2_RE = new RegExp(

package/telegram-plugin/uat/feed-matcher.test.ts

@@ -52,29 +52,36 @@ describe("isWorkerFeedMessage", () => {
     expect(WORKER_FEED_RE.test("🛠 Worker · x")).toBe(true);
   });
 
-  it("still matches the #3820 SUBORDINATE worker card as Telegram delivers it", () => {
-    // Since #3820 the worker card leads with `└─ ` and indents every later line
-    // with a U+2800 run so it reads as a child of the 🤖 agent card. Telegram
-    // strips the bold/italic entities but delivers that chrome verbatim, and
-    // `String.trim()` removes neither (U+2800 is category So, not whitespace) —
-    // so every matcher here has to survive it or recall/reply scenarios start
-    // latching onto worker cards as answers.
-    const nested = "└─ 🛠 WORKER · crawling changelog\n⠀⠀⠀55s · 9 tools · opus 5";
-    expect(isWorkerFeedMessage(feed(nested))).toBe(true);
+  it("matches the FLUSH worker card as Telegram delivers it (#3842)", () => {
+    // #3842 removed the whole-card `└─ ` prefix and whole-card indent that
+    // #3820/#3821 put on worker cards, so the single-worker card arrives flush.
+    const flush = "🛠 WORKER · crawling changelog\n55s · 9 tools · opus 5";
+    expect(isWorkerFeedMessage(feed(flush))).toBe(true);
   });
 });
 
-describe("#3820 subordinate-card nesting is transparent to the matchers", () => {
-  it("classifies a nested agent-shaped card as the liveness card, not an answer", () => {
-    const nested =
-      "└─ 🛠 WORKER · crawl\n⠀⠀⠀12s · 3 tools\n⠀⠀⠀✓ Reading CLAUDE.md\n⠀⠀⠀→ Searching memory";
-    expect(isLivenessCardMessage(feed(nested))).toBe(true);
-    expect(isActivityFeedMessage(feed(nested))).toBe(true);
+describe("#3842 the surviving step indent is transparent to the matchers", () => {
+  it("classifies a flush agent-shaped worker card as the liveness card, not an answer", () => {
+    const flush =
+      "🛠 WORKER · crawl\n12s · 3 tools\n✓ Reading CLAUDE.md\n→ Searching memory";
+    expect(isLivenessCardMessage(feed(flush))).toBe(true);
+    expect(isActivityFeedMessage(feed(flush))).toBe(true);
   });
 
-  it("strips the header prefix and the indent, and leaves ordinary prose alone", () => {
-    expect(stripCardNesting("└─ 🛠 WORKER · crawl")).toBe("🛠 WORKER · crawl");
+  it("classifies a combined card whose step lines carry WORKER_STEP_INDENT", () => {
+    // The one indent that survives #3842: step lines under a worker row header
+    // on the 2+ worker card. `String.trim()` does NOT remove U+2800 (category
+    // So, not whitespace), so the matchers must normalise it explicitly or a
+    // recall/reply scenario latches onto the combined card as an answer.
+    const combined =
+      "🛠 WORKERS · 2 running · oldest 55s · 13 tools\n" +
+      "1. crawl · 55s · 9 tools\n⠀⠀⠀✓ Reading CLAUDE.md\n⠀⠀⠀→ Searching memory";
+    expect(isWorkerFeedMessage(feed(combined))).toBe(true);
+  });
+
+  it("strips the step indent and leaves ordinary prose alone", () => {
     expect(stripCardNesting("⠀⠀⠀→ Searching memory")).toBe("→ Searching memory");
+    expect(stripCardNesting("🛠 WORKER · crawl")).toBe("🛠 WORKER · crawl");
     expect(stripCardNesting("on it, pulling the logs now")).toBe(
       "on it, pulling the logs now",
     );

package/telegram-plugin/worker-activity-feed.ts

@@ -53,13 +53,9 @@ import {
   cleanWorkerResultParagraph,
   stripMarkdown,
   truncate,
-  COLLAPSE_SAFE_SEPARATOR,
 } from './card-format.js'
-import {
-  WORKER_HISTORY_MAX,
-  SUBORDINATE_HEADER_PREFIX,
-  SUBORDINATE_LINE_INDENT,
-} from './status-no-truncate.js'
+import { WORKER_HISTORY_MAX } from './status-no-truncate.js'
+import { renderCardTitleLine } from './card-layout.js'
 import {
   renderStatusCard,
   formatStepSuffix,
@@ -130,6 +126,49 @@ export interface WorkerActivityView {
   model?: string
 }
 
+/**
+ * Out-of-band metadata about ONE feed edit, handed to the transport adapter
+ * alongside the Bot API arguments (switchroom#3848).
+ *
+ * Deliberately a SEPARATE parameter rather than a field on `opts`: `opts` is
+ * forwarded verbatim to `editMessageText` and therefore onto the wire, and
+ * `outbound-class.ts` exists precisely so a priority signal never has to be
+ * smuggled into an outbound Bot API payload.
+ */
+export interface WorkerFeedEditMeta {
+  /**
+   * True when this edit paints the card's FINAL state — the last worker's
+   * terminal recap, or the "superseded" note on a rotated-out message. False
+   * for every intermediate / liveness repaint.
+   */
+  terminal: boolean
+}
+
+/**
+ * The send-gate priority class a worker-feed edit must carry.
+ *
+ * Intermediate repaints are `cosmetic`: dropping one costs nothing, because
+ * the next render carries full state, and holding them to the fuse's tight
+ * cosmetic ceilings (4/message/60s, 6/chat/60s) is what stops the feed
+ * earning a per-chat flood ban (#3847).
+ *
+ * A TERMINAL frame is `useful` (#3848). It is the last frame the operator
+ * ever reads for that card and nothing newer is coming to repaint it, so
+ * classing it cosmetic made the one frame carrying the finished state
+ * compete in — and get shed from — the same starved budget as a heartbeat.
+ * `useful` rather than `critical` matches the activity-summary finalize in
+ * `gateway/narrative-lane.ts`: it may be DEFERRED under pressure, but it is
+ * not shed, and it does not spend the per-chat reply reservation that keeps
+ * the operator's real answer unstarvable.
+ *
+ * Exported so the mapping is unit-testable; `gateway.ts` only calls it.
+ */
+export function workerFeedEditPriorityClass(
+  meta?: WorkerFeedEditMeta,
+): 'useful' | 'cosmetic' {
+  return meta?.terminal === true ? 'useful' : 'cosmetic'
+}
+
 export interface BotApiForWorkerFeed {
   sendMessage(
     chatId: string,
@@ -141,6 +180,12 @@ export interface BotApiForWorkerFeed {
     messageId: number,
     text: string,
     opts?: Record<string, unknown>,
+    /**
+     * Out-of-band edit metadata (NOT part of the Bot API payload). The
+     * gateway adapter maps `terminal` to the send-gate priority class via
+     * {@link workerFeedEditPriorityClass}.
+     */
+    meta?: WorkerFeedEditMeta,
   ): Promise<unknown>
 }
 
@@ -168,30 +213,32 @@ export function repeatCountOf(line: string): number {
 
 /**
  * Thin adapter over the unified `renderStatusCard` primitive (emoji 🛠, label
- * 'WORKER', `subordinate: true`): builds the header, passes raw narrative steps
+ * 'WORKER'): builds the header, passes raw narrative steps
  * (the primitive runs stripMarkdown → collapse ws → clip → escape per line),
  * and on finish passes the cleaned result paragraph as the `result` block.
  *
  * Layout (running):
- *   └─ 🛠 **WORKER** · _{description}_
- *      _{elapsed} · {n} tools_
- *      ~~_✓ {earlier step}_~~
- *      **→ {newest step}**
+ *   🛠 **WORKER** · _{description}_
+ *   _{elapsed} · {n} tools_
+ *   ~~_✓ {earlier step}_~~
+ *   **→ {newest step}**
  *
  * Layout (finished): the feed renders all-done, then a rule + cleaned result:
- *   └─ 🛠 **WORKER** · _{description}_
- *      _done · {n} tools · {elapsed}_
- *      ~~_✓ {step}_~~
- *      ─────
- *      ✅ _{cleaned result paragraph}_
+ *   🛠 **WORKER** · _{description}_
+ *   _done · {n} tools · {elapsed}_
+ *   ~~_✓ {step}_~~
+ *   ─────
+ *   ✅ _{cleaned result paragraph}_
  *
- * SUBORDINATION (#3820): the `└─ ` prefix, the whole-block indent, and the
- * caps `WORKER` label exist so this card cannot be mistaken for the 🤖 agent
- * card at a glance on a phone. Before #3820 the two cards differed only by
- * their emoji and one capitalised word while sharing the identical two-line
- * header, stat row, and step trail. Do NOT "tidy" any of the three away
- * individually: each is a separate one-glance cue, and the pair is frequently
- * live in the same chat at the same time with overlapping step text.
+ * FLUSH (#3842): this card sits at the left margin. #3820/#3821 indented the
+ * whole block and prefixed line 1 with `└─ ` to mark it subordinate to the 🤖
+ * agent card; that was reverted because it burned a level of horizontal phone
+ * width and because this card does not always sit below the agent card, so a
+ * card-level subordination marker asserts a relationship that is not always
+ * true. The remaining type cue is line 1: the 🛠 emoji plus the caps `WORKER`
+ * label against the agent card's 🤖 `Agent`. Keep that pair — with identical
+ * step text and stats the two cards' BODY lines can now coincide byte for
+ * byte, so line 1 is doing all of the distinguishing work.
  */
 export function renderWorkerActivity(v: WorkerActivityView, liveSuffix = ''): string {
   const desc = truncate(stripMarkdown(v.description).trim() || 'background task', DESC_MAX)
@@ -239,9 +286,6 @@ export function renderWorkerActivity(v: WorkerActivityView, liveSuffix = ''): st
     if (text.length > 0) result = { emoji: v.state === 'done' ? '✅' : '⚠️', text }
   }
 
-  // `renderStatusCard` always returns content when a header is supplied. When
-  // running with no steps it shows just the header — append a "starting…" line
-  // for parity with the prior behaviour.
   const card = renderStatusCard({
     header,
     steps,
@@ -251,25 +295,18 @@ export function renderWorkerActivity(v: WorkerActivityView, liveSuffix = ''): st
     // Lone-worker card: window to the w=1 point of Ken's curve (6) so it shows
     // the full recent trail, not the 5-line agent-card default (#3349).
     historyWindow: workerHistoryDepth(1),
-    // Structurally subordinate to the 🤖 agent card (#3820).
-    subordinate: true,
+    // A just-dispatched worker has no narrative yet. The placeholder is a normal
+    // BODY line of the shared spec now (#3846): it used to be concatenated onto
+    // this function's return value, which put a user-visible card line outside
+    // the primitive that owns hard-break stacking, the collapse-safe separator
+    // and the char budget, and made the seam the one boundary that could mash in
+    // Telegram's pinned bar. Only while RUNNING — a finished worker with no
+    // steps must not read as "starting…".
+    emptyPlaceholder: finished ? undefined : '_starting…_',
   })
   if (card == null) {
     // Unreachable (header always present) — defensive.
-    return `${SUBORDINATE_HEADER_PREFIX}🛠 **WORKER** · _starting…_`
-  }
-  if (!finished && steps.length === 0) {
-    // Header-only running render → append the starting placeholder with a GFM
-    // hard break (`  \n`) so it stacks under the header instead of collapsing
-    // onto the header line in the rich-message renderer (matches stackCardLines).
-    // The collapse separator is carried here too (#3666) — this card is pinned,
-    // and a hand-rolled seam would be the one boundary that still mashed in
-    // Telegram's pinned bar.
-    // The placeholder is a card BODY line, so it carries the subordinate indent
-    // like every other non-header line (#3820) — otherwise the one render state
-    // a user sees first (a just-dispatched worker) would be the one that isn't
-    // visibly nested.
-    return `${card}${COLLAPSE_SAFE_SEPARATOR}  \n${SUBORDINATE_LINE_INDENT}_starting…_`
+    return renderCardTitleLine('🛠', 'WORKER', 'starting…')
   }
   return card
 }
@@ -616,10 +653,21 @@ const COOLDOWN_JITTER_MS = 500
  * rows and reads like a stuck worker. A single best-effort edit collapses it to
  * an honest "moved" note — issued once per rotation (≥ cap interval), never per
  * tick, so it adds no edit churn / pin storm. Plain voice, no em dash.
+ *
+ * Exported so the card-preview harness (`scripts/card-previews.ts`) renders the
+ * real string rather than a copy that can drift from it.
+ *
+ * DELIBERATELY still a constant, not a card render (#3846). It shows no live
+ * state — no elapsed, no tool count, no steps — so there is nothing for a
+ * renderer to compose and no rolling window or char budget to enforce; routing
+ * it through `renderStatusCard` would mean inventing a state to render. What it
+ * DOES share with every other card is its type chrome, so line 1 comes from the
+ * one title composer (`renderCardTitleLine`): if the 🛠 / **WORKER** convention
+ * ever changes, this notice moves with it instead of being the one stale card.
  */
-const WORKER_CARD_SUPERSEDED_BODY =
-  `${SUBORDINATE_HEADER_PREFIX}🛠 **WORKER** · _continued_\n\n` +
-  `${SUBORDINATE_LINE_INDENT}_Live progress moved to a fresh card to stay pinned._`
+export const WORKER_CARD_SUPERSEDED_BODY =
+  `${renderCardTitleLine('🛠', 'WORKER', 'continued')}\n\n` +
+  '_Live progress moved to a fresh card to stay pinned._'
 
 function extractRetryAfterSecs(err: unknown): number | null {
   if (err == null || typeof err !== 'object') return null
@@ -1197,7 +1245,11 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
     }
 
     try {
-      const res = await opts.bot.editMessageText(g.chatId, g.messageId, body, sendOptsFor(g))
+      // #3848: tell the transport whether this is the card's LAST frame. A
+      // terminal recap must not be shed with the heartbeat repaints.
+      const res = await opts.bot.editMessageText(
+        g.chatId, g.messageId, body, sendOptsFor(g), { terminal: isTerminal },
+      )
       // Shed honesty (#3084): a cosmetic edit the gate shed resolves the
       // distinguishable SEND_GATE_SHED sentinel (NOT a bare `undefined`, which
       // the gate reserves for a benign no-op drop whose payload IS on screen).
@@ -1486,8 +1538,14 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
         // doesn't sit frozen showing live-styled rows (mistakable for a stuck
         // worker). ONE best-effort edit per rotation (≥ cap interval), fired
         // off-chain and swallowing errors — never per-tick, never a burst.
+        // #3848: terminal — this is the retired message's LAST frame, and it
+        // fires at most once per `groupMessageLifetimeCapMs`, so promoting it
+        // out of the cosmetic budget costs nothing and stops the retired card
+        // being left frozen showing live-styled rows.
         void opts.bot
-          .editMessageText(g.chatId, retiredId, WORKER_CARD_SUPERSEDED_BODY, sendOptsFor(g))
+          .editMessageText(
+            g.chatId, retiredId, WORKER_CARD_SUPERSEDED_BODY, sendOptsFor(g), { terminal: true },
+          )
           .catch(() => {})
       }
 

package/vendor/hindsight-memory/CLAUDE.md

@@ -0,0 +1,45 @@
+# CLAUDE.md — vendor/hindsight-memory
+
+**This directory is a VENDORED SNAPSHOT of the hindsight-memory plugin. It is
+not the specification, and it is not what runs.** Treat it as evidence about
+one commit of the implementation, nothing more.
+
+The load-bearing copy of this rule is the repo-root `CLAUDE.md`
+("Third-party docs — the official site is the spec"); nothing auto-loads a
+subdirectory `CLAUDE.md`, so this file only reaches an agent that opens it.
+
+## Where the truth is
+
+1. **Official docs site** — <https://hindsight.vectorize.io/>. Curation and
+   the memory-unit endpoints: `/developer/api/memories`. Also
+   `/developer/api/retain`, `/developer/api/recall`,
+   `/developer/observations`, `/developer/configuration`, index at
+   `/api-reference`. (`/developer/` itself has no index page — it 404s.)
+2. **context7** — prefer `/websites/hindsight_vectorize_io` (the docs site)
+   over `/vectorize-io/hindsight` (the OSS repo).
+3. **This tree** — last, and only for "what does the code here actually do".
+
+Not finding something here is not evidence it doesn't exist. Search the docs
+before you tell anyone a knob, endpoint or config path is unsupported.
+
+## Trap: `settings.json` here is NOT what switchroom installs
+
+`installHindsightPlugin` (`src/agents/scaffold.ts`) copies this tree into each
+agent's `.claude/plugins/hindsight-memory/` and then **stamps switchroom's own
+overrides over `settings.json`** — additional banks, the retain cadence knobs,
+and the recall types. Concretely, this file has
+`"recallTypes": ["world", "experience"]` while switchroom writes
+`["world", "experience", "observation"]` (`scaffold.ts:3449` as of writing;
+line anchors drift — grep `settings.recallTypes`).
+
+So reading the vendored `settings.json` to learn live behaviour is actively
+misleading. Read the override site in `scaffold.ts`, or the deployed
+`~/.switchroom/agents/<name>/.claude/plugins/hindsight-memory/settings.json`.
+
+## Editing
+
+Don't hand-edit vendored upstream files without a reason (repo-root
+`CLAUDE.md` § Secrets & safety rails). This file and switchroom's local
+patches are the exceptions; changes here ship to every agent on the next
+`apply`/reconcile, and the Python under `scripts/` is gated by the required
+`python-ok` check (`python3 -m unittest discover` in `scripts`).

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

@@ -46,6 +46,20 @@ DEFAULTS = {
     # cap of 6 its fleet actually deploys.
     "recallOwnBankMinSlots": 0,
     "recallAdditionalBankMinSlots": 0,
+    # Switchroom #3837: absolute floor on a result's engine relevance score
+    # (`scores.final`) for it to be injected. 0.0 (default) DISABLES the floor
+    # — nothing is dropped and the injected set is byte-identical to the
+    # pre-#3837 behaviour. `recallMinScoreScope` decides which turns a
+    # non-zero floor binds on: "degraded" (default) = only turns where the
+    # agent's OWN bank timed out or was unreachable, which is the population
+    # where a below-floor score actually predicts noise (98.4% of degraded
+    # rows have a best injected score under 0.01, against 28.4% of healthy
+    # ones); "all" = every turn, which #3761's replay says empties ~28% of
+    # HEALTHY recalls at 0.01 and is not recommended as a fleet default. See
+    # the design note above `_filter_by_min_score` in recall.py. Env:
+    # HINDSIGHT_RECALL_MIN_SCORE / HINDSIGHT_RECALL_MIN_SCORE_SCOPE.
+    "recallMinScore": 0.0,
+    "recallMinScoreScope": "degraded",
     "recallTypes": ["world", "experience"],
     # Switchroom-local: when True (default; Ken-approved ON) recall biases
     # toward synthesized `observation`-tier facts. Escape hatch: pin off via
@@ -324,6 +338,12 @@ ENV_OVERRIDES = {
     # .additional_bank_min_slots (cascading through defaults). 0 = off.
     "HINDSIGHT_RECALL_OWN_BANK_MIN_SLOTS": ("recallOwnBankMinSlots", int),
     "HINDSIGHT_RECALL_ADDITIONAL_BANK_MIN_SLOTS": ("recallAdditionalBankMinSlots", int),
+    # Switchroom #3837: absolute `scores.final` floor + the population it binds
+    # on. Set by start.sh from agents.<name>.memory.recall.min_score /
+    # .min_score_scope (cascading through defaults), exported only when the
+    # operator opted in. 0.0 = off (the default, and the shipped behaviour).
+    "HINDSIGHT_RECALL_MIN_SCORE": ("recallMinScore", float),
+    "HINDSIGHT_RECALL_MIN_SCORE_SCOPE": ("recallMinScoreScope", str),
     # Switchroom-local: recall fact types (comma-separated). Set by start.sh
     # from agents.<name>.memory.recall.types only when the operator overrode
     # the switchroom default (world,experience,observation) — i.e. the
@@ -333,6 +353,19 @@ ENV_OVERRIDES = {
     # from agents.<name>.memory.recall.skip_trivial only on override; the
     # switchroom default is on (recall.py falls back to True).
     "HINDSIGHT_RECALL_SKIP_TRIVIAL": ("recallSkipTrivial", bool),
+    # Switchroom #3841: the last three recall settings that had a config key but
+    # no env channel at all, so switchroom.yaml could not reach them and a
+    # hand-edit of the installed plugin did not survive `switchroom apply`. Set
+    # by start.sh from agents.<name>.memory.recall.prefer_observations / .roles /
+    # .prompt_preamble (cascading through defaults), always exported at their
+    # existing effective values, so an operator who sets none of them sees no
+    # change. The other #3841 knobs (budget, max_tokens, context_turns,
+    # max_query_chars, transcript_tail_bytes, tags, tags_match, tag_groups,
+    # tag_weights, additional_bank_filters, transcript_fallback, parallel)
+    # already had entries in this table and only needed the yaml surface.
+    "HINDSIGHT_RECALL_PREFER_OBSERVATIONS": ("recallPreferObservations", bool),
+    "HINDSIGHT_RECALL_ROLES": ("recallRoles", list),
+    "HINDSIGHT_RECALL_PROMPT_PREAMBLE": ("recallPromptPreamble", str),
     # Switchroom #2848 Stage B: directive-capture nudge on/off. Set by
     # start.sh from agents.<name>.memory.directive_capture_nudge only when
     # the operator overrode it; the switchroom default is on (settings.json