switchroom 0.15.40 → 0.15.42

package/telegram-plugin/tests/context-occupancy.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'bun:test'
+import {
+  buildContextOccupancy,
+  writeContextOccupancySnapshot,
+  TIGHT_FRACTION,
+} from '../gateway/context-occupancy.js'
+
+describe('buildContextOccupancy', () => {
+  it('computes headroom + pct + ok state under the cap', () => {
+    const s = buildContextOccupancy(47000, 300000, 123)
+    expect(s).toMatchObject({ occupancy: 47000, cap: 300000, headroom: 253000, state: 'ok', computedAt: 123 })
+    expect(s.pct).toBeCloseTo(0.1567, 3)
+  })
+
+  it('flags "tight" at/above TIGHT_FRACTION of the cap', () => {
+    const atThreshold = buildContextOccupancy(Math.ceil(300000 * TIGHT_FRACTION), 300000, 1)
+    expect(atThreshold.state).toBe('tight')
+    expect(buildContextOccupancy(250000, 300000, 1).state).toBe('tight') // 83% ≥ 80%
+    expect(buildContextOccupancy(231000, 300000, 1).state).toBe('ok')    // 77% < 80%
+    expect(buildContextOccupancy(239999, 300000, 1).state).toBe('ok')    // just under 80%
+  })
+
+  it('no cap → ok, null ratio (occupancy known, no ceiling)', () => {
+    const s = buildContextOccupancy(50000, null, 1)
+    expect(s).toMatchObject({ occupancy: 50000, cap: null, headroom: null, pct: null, state: 'ok' })
+    expect(buildContextOccupancy(50000, 0, 1).cap).toBeNull() // cap<=0 treated as none
+  })
+
+  it('unmeasurable occupancy → unknown', () => {
+    expect(buildContextOccupancy(NaN, 300000, 1).state).toBe('unknown')
+    expect(buildContextOccupancy(-5, 300000, 1).state).toBe('unknown')
+  })
+})
+
+describe('writeContextOccupancySnapshot', () => {
+  it('writes <stateDir>/context-occupancy.json via injected fs', () => {
+    let path = ''
+    let data = ''
+    writeContextOccupancySnapshot('/state/agent', buildContextOccupancy(47000, 300000, 1), {
+      mkdir: () => {},
+      writeFile: (p, d) => { path = p; data = d },
+    })
+    expect(path).toBe('/state/agent/context-occupancy.json')
+    expect(JSON.parse(data).occupancy).toBe(47000)
+  })
+
+  it('never throws when the write fails (best-effort)', () => {
+    expect(() =>
+      writeContextOccupancySnapshot('/x', buildContextOccupancy(1, 2, 1), {
+        mkdir: () => {},
+        writeFile: () => { throw new Error('EACCES') },
+      }),
+    ).not.toThrow()
+  })
+})

package/telegram-plugin/tests/idle-clear.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest'
+import {
+  decideIdleClear,
+  idleDurationToMs,
+  DEFAULT_IDLE_CLEAR_MS,
+  type IdleClearState,
+} from '../gateway/idle-clear.js'
+
+const H = 3_600_000
+function state(p: Partial<IdleClearState>): IdleClearState {
+  return { lastActivityAt: 0, idleClearMs: 3 * H, alreadyCleared: false, turnInFlight: false, ...p }
+}
+
+describe('decideIdleClear', () => {
+  it('fires once the idle window has elapsed', () => {
+    expect(decideIdleClear(state({ lastActivityAt: 0 }), 3 * H).clear).toBe(true)
+    expect(decideIdleClear(state({ lastActivityAt: 0 }), 3 * H + 1).clear).toBe(true)
+  })
+
+  it('does NOT fire before the window', () => {
+    expect(decideIdleClear(state({ lastActivityAt: 0 }), 3 * H - 1).clear).toBe(false)
+  })
+
+  it('never fires mid-turn (turnInFlight)', () => {
+    expect(decideIdleClear(state({ lastActivityAt: 0, turnInFlight: true }), 10 * H).clear).toBe(false)
+  })
+
+  it('fires once per idle period (alreadyCleared guard)', () => {
+    expect(decideIdleClear(state({ lastActivityAt: 0, alreadyCleared: true }), 10 * H).clear).toBe(false)
+  })
+
+  it('is disabled when idleClearMs <= 0', () => {
+    expect(decideIdleClear(state({ lastActivityAt: 0, idleClearMs: 0 }), 10 * H).clear).toBe(false)
+    expect(decideIdleClear(state({ lastActivityAt: 0, idleClearMs: -1 }), 10 * H).clear).toBe(false)
+  })
+
+  it('re-arms after activity (fresh lastActivityAt + alreadyCleared=false → waits again)', () => {
+    // Simulated: after a clear, activity resets lastActivityAt to `now` and the flag.
+    const now = 100 * H
+    const reArmed = state({ lastActivityAt: now, alreadyCleared: false })
+    expect(decideIdleClear(reArmed, now + 3 * H - 1).clear).toBe(false) // not yet
+    expect(decideIdleClear(reArmed, now + 3 * H).clear).toBe(true) // again, one window later
+  })
+})
+
+describe('idleDurationToMs', () => {
+  it('parses s/m/h', () => {
+    expect(idleDurationToMs('3h')).toBe(3 * H)
+    expect(idleDurationToMs('90m')).toBe(90 * 60_000)
+    expect(idleDurationToMs('7200s')).toBe(7_200_000)
+    expect(idleDurationToMs('0s')).toBe(0) // disable sentinel
+  })
+  it('returns null on malformed input (caller falls back to default)', () => {
+    expect(idleDurationToMs('3')).toBeNull()
+    expect(idleDurationToMs('3d')).toBeNull()
+    expect(idleDurationToMs('abc')).toBeNull()
+    expect(idleDurationToMs('')).toBeNull()
+  })
+  it('default is 3h', () => {
+    expect(DEFAULT_IDLE_CLEAR_MS).toBe(3 * H)
+  })
+})

package/telegram-plugin/tests/poll-stall-recovery.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import {
+  recoverFromPollStall,
+  POLL_STALL_EXIT_CODE,
+} from '../gateway/poll-stall-recovery.js'
+
+describe('recoverFromPollStall', () => {
+  it('exits with code 1 — and NEVER 78 (78 = permanent quarantine)', () => {
+    const codes: number[] = []
+    recoverFromPollStall({ exit: (c) => { codes.push(c) }, log: () => {} })
+    expect(codes).toEqual([1])
+    expect(POLL_STALL_EXIT_CODE).toBe(1)
+    expect(codes).not.toContain(78) // the sharp edge: quarantine on a transient stall
+  })
+
+  it('logs a recovery line carrying the agent name + the reason (no stop() await)', () => {
+    const lines: string[] = []
+    recoverFromPollStall({ exit: () => {}, log: (m) => { lines.push(m) }, agentName: 'carrie' })
+    expect(lines).toHaveLength(1)
+    expect(lines[0]).toContain('stall_recovery')
+    expect(lines[0]).toContain('agent=carrie')
+    expect(lines[0]).toContain('code=1')
+    // documents WHY we don't await stop() — guards against a future revert
+    expect(lines[0]).toMatch(/backoff|stop\(\)/)
+  })
+
+  it('exits exactly once', () => {
+    let calls = 0
+    recoverFromPollStall({ exit: () => { calls++ }, log: () => {} })
+    expect(calls).toBe(1)
+  })
+})

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

@@ -12,7 +12,6 @@ import {
   switchroomHelpCommandNames,
   restartAckText,
   newSessionAckText,
-  resetSessionAckText,
   TELEGRAM_BASE_COMMANDS,
   TELEGRAM_SWITCHROOM_COMMANDS,
   TELEGRAM_MENU_COMMANDS,
@@ -137,7 +136,8 @@ describe("helpText", () => {
     expect(out).toContain("/deny");
     expect(out).toContain("/pending");
     expect(out).toContain("/new");
-    expect(out).toContain("/reset");
+    expect(out).toContain("/compact");
+    expect(out).toContain("/clear");
   });
   it("points at the richer /commands", () => {
     expect(helpText("assistant")).toContain("/commands");
@@ -347,9 +347,11 @@ describe("switchroomHelpText + switchroomHelpCommandNames", () => {
     expect(out).toContain("<b>Auth &amp; config</b>");
   });
   it("the name array contains the Sprint 2/3 additions", () => {
-    for (const needed of ["new", "reset", "approve", "deny", "pending"]) {
+    for (const needed of ["new", "compact", "clear", "approve", "deny", "pending"]) {
       expect(switchroomHelpCommandNames).toContain(needed);
     }
+    // /reset was removed (it was a pure alias of /new).
+    expect(switchroomHelpCommandNames).not.toContain("reset");
   });
 });
 
@@ -370,9 +372,11 @@ describe("TELEGRAM_MENU_COMMANDS (slash-menu shape)", () => {
   it("menu includes the session-control commands (the most-used trio)", () => {
     const names = TELEGRAM_MENU_COMMANDS.map(c => c.command);
     // These MUST be in the menu — they're the primary mobile UX flows
-    for (const must of ["new", "reset", "approve", "deny", "pending", "restart", "logs", "commands"]) {
+    for (const must of ["new", "compact", "clear", "approve", "deny", "pending", "restart", "logs", "commands"]) {
       expect(names, `missing /${must} from Telegram menu`).toContain(must);
     }
+    // /reset removed (alias of /new).
+    expect(names, "/reset should be gone from the menu").not.toContain("reset");
   });
 
   it("menu drops the ops primitives that cluttered the old catalogue", () => {
@@ -451,7 +455,7 @@ describe("TELEGRAM_MENU_COMMANDS (slash-menu shape)", () => {
   });
 });
 
-describe("restart / new / reset ack text", () => {
+describe("restart / new ack text", () => {
   it("restartAckText is consistent", () => {
     expect(restartAckText("assistant")).toBe("🔄 Restarting <b>assistant</b>…");
   });
@@ -463,13 +467,8 @@ describe("restart / new / reset ack text", () => {
     expect(newSessionAckText("assistant", false))
       .toBe("🆕 Started fresh session for <b>assistant</b> · restarting…");
   });
-  it("resetSessionAckText with flush", () => {
-    expect(resetSessionAckText("assistant", true))
-      .toBe("🔄 Reset session for <b>assistant</b> · flushed handoff · restarting…");
-  });
-  it("HTML-escapes agent name in all three", () => {
+  it("HTML-escapes agent name in both", () => {
     expect(restartAckText("<x>")).toContain("&lt;x&gt;");
     expect(newSessionAckText("<x>", true)).toContain("&lt;x&gt;");
-    expect(resetSessionAckText("<x>", true)).toContain("&lt;x&gt;");
   });
 });

package/telegram-plugin/welcome-text.ts

@@ -170,7 +170,7 @@ export function helpText(agentName: string): string {
     ``,
     `This bot is the <b>${escapeHtml(agentName)}</b> agent. Text and photos route through to it; replies, reactions and progress cards come back.`,
     ``,
-    `Tool approvals surface as inline buttons (✅ / ❌) or via <code>/approve</code>, <code>/deny</code>, <code>/pending</code>. Start a fresh session with <code>/new</code> or <code>/reset</code>.`,
+    `Tool approvals surface as inline buttons (✅ / ❌) or via <code>/approve</code>, <code>/deny</code>, <code>/pending</code>. Start a fresh session with <code>/new</code>, or trim/clear context with <code>/compact</code> / <code>/clear</code>.`,
     ``,
     `<code>/start</code> — pairing instructions`,
     `<code>/status</code> — agent, model, auth`,
@@ -265,7 +265,7 @@ export function statusUnpairedText(): string {
  */
 export const switchroomHelpCommandNames = [
   // Session & approvals
-  "new", "reset", "approve", "deny", "pending", "interrupt",
+  "new", "compact", "clear", "approve", "deny", "pending", "interrupt",
   // Agents
   "agents", "agentstart", "stop", "restart", "logs", "memory",
   // Auth & config — consolidated onto the `/auth` dashboard.
@@ -298,7 +298,8 @@ export const TELEGRAM_MENU_COMMANDS = [
   { command: "status", description: "Agent, model, auth" },
   // Session control (most-used)
   { command: "new", description: "Fresh session (flush handoff, restart)" },
-  { command: "reset", description: "Alias of /new" },
+  { command: "compact", description: "Compact context (summarize, keep the thread)" },
+  { command: "clear", description: "Clear context (fresh slate; memory in Hindsight)" },
   // Inline approvals
   { command: "approve", description: "Approve pending tool permission" },
   { command: "deny", description: "Deny pending tool permission" },
@@ -312,8 +313,10 @@ export const TELEGRAM_MENU_COMMANDS = [
   // #725 Phase 2 — inject a Claude Code REPL slash command into the agent's
   // tmux pane (allowlisted: /cost, /status, /model, /clear, /compact,
   // /memory, /hooks). Requires the tmux supervisor (the default — refused
-  // when the agent has experimental.legacy_pty=true).
-  { command: "inject", description: "Inject a Claude Code slash command (e.g. /cost)" },
+  // when the agent has experimental.legacy_pty=true). NOT in the slash-menu
+  // (kept the 20-entry mobile cap; the common injects /compact, /clear,
+  // /model, /effort are first-class menu commands). Still typable + in
+  // /commands.
   // /model — show or switch the Claude model (session-scoped; rides the
   // same inject primitive as `/inject /model` but with a typed argument,
   // so it never opens the undriveable no-arg picker modal).
@@ -356,7 +359,8 @@ export function switchroomHelpText(agentName: string): string {
     ``,
     `<b>Session &amp; approvals</b>`,
     `<code>/new</code> — fresh session (flush handoff, restart)`,
-    `<code>/reset</code> — alias of /new`,
+    `<code>/compact</code> — compact context (summarize, keep the thread)`,
+    `<code>/clear</code> — clear context (fresh slate; memory in Hindsight)`,
     `<code>/approve [id]</code> — approve pending tool permission`,
     `<code>/deny [id]</code> — deny pending tool permission`,
     `<code>/pending</code> — list pending permission prompts`,
@@ -404,7 +408,7 @@ export function switchroomHelpText(agentName: string): string {
 }
 
 /**
- * Ack shown when a self-targeting /restart (or /new, /reset) kicks off.
+ * Ack shown when a self-targeting /restart (or /new) kicks off.
  * Centralized so gateway and monolith agree on wording.
  */
 export function restartAckText(agentName: string): string {
@@ -415,8 +419,3 @@ export function newSessionAckText(agentName: string, flushedHandoff: boolean): s
   const tail = flushedHandoff ? " · flushed handoff" : "";
   return `🆕 Started fresh session for <b>${escapeHtml(agentName)}</b>${tail} · restarting…`;
 }
-
-export function resetSessionAckText(agentName: string, flushedHandoff: boolean): string {
-  const tail = flushedHandoff ? " · flushed handoff" : "";
-  return `🔄 Reset session for <b>${escapeHtml(agentName)}</b>${tail} · restarting…`;
-}

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

@@ -98,6 +98,15 @@ ENV_OVERRIDES = {
     # [0.0, 1.0]. Set by start.sh from agents.<name>.memory.recall.min_overlap
     # (cascading through defaults). 0.0 = off (current behaviour).
     "HINDSIGHT_RECALL_MIN_OVERLAP": ("recallMinOverlap", float),
+    # 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
+    # opt-out path for the synthesized `observation` tier.
+    "HINDSIGHT_RECALL_TYPES": ("recallTypes", list),
+    # Switchroom-local: trivial-turn recall skip (Phase 6a). Set by start.sh
+    # 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),
     "HINDSIGHT_RECALL_MAX_QUERY_CHARS": ("recallMaxQueryChars", int),
     "HINDSIGHT_RECALL_CONTEXT_TURNS": ("recallContextTurns", int),
     "HINDSIGHT_API_PORT": ("apiPort", int),
@@ -121,6 +130,9 @@ def _cast_env(value: str, typ):
             return int(value)
         if typ is float:
             return float(value)
+        if typ is list:
+            # Comma-separated → list of trimmed, non-empty strings.
+            return [t.strip() for t in value.split(",") if t.strip()]
         return value
     except (ValueError, AttributeError):
         return None

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

@@ -42,6 +42,7 @@ Exit codes:
 import hashlib
 import json
 import os
+import re
 import sys
 import time
 
@@ -466,6 +467,57 @@ def read_transcript_messages(transcript_path: str) -> list:
     return messages
 
 
+# Switchroom Phase 6a — stateless-prompt classifier for the recall skip.
+# Returns True ONLY for prompts that provably never need user memory: the
+# current time/date/day, or a bare greeting. Biased hard toward False —
+# any personal pronoun, memory verb, or context word means "could need
+# memory → recall anyway". Trap case: "what host am I on" reads trivial
+# but needs memory; the "i" token blocks the skip.
+_TRIVIAL_GREETINGS = frozenset({
+    "hi", "hello", "hey", "heya", "hiya", "yo", "howdy", "sup",
+    "hey there", "hello there", "hi there",
+    "morning", "good morning", "good afternoon", "good evening", "evening",
+})
+# Any of these as a whole word → do NOT skip (prompt may depend on stored
+# user / project / session state).
+_STATEFUL_SIGNALS = frozenset({
+    "i", "im", "ive", "id", "me", "my", "mine", "myself",
+    "we", "our", "ours", "us", "you", "your", "yours",
+    "remember", "recall", "forget", "forgot", "remind",
+    "last", "earlier", "yesterday", "before", "again", "previously", "recent",
+    "project", "task", "status", "config", "setup", "host", "machine",
+    "running", "deploy", "agent", "memory", "note", "noted",
+})
+# Matched against an apostrophe-stripped form, so "what's"→"whats",
+# "today's"→"todays". Covers "what time is it", "what's the time",
+# "what day is it", "what's today's date", "current time", "time?".
+_STATELESS_QUESTION_RE = re.compile(
+    r"^(?:what(?:s| is)?\s+)?"
+    r"(?:the\s+|current\s+|todays\s+)?"
+    r"(?:time|date|day(?:\s+of\s+(?:the\s+)?week)?)"
+    r"(?:\s+is\s+it)?(?:\s+(?:right\s+now|now|today))?"
+    r"\s*\??$"
+)
+
+
+def _is_trivial_stateless(ack_form, stripped):
+    text = (stripped or "").lower().strip()
+    core = text.strip(" \t\n\r.,!?…👍👌✅🆗🙏")
+    if not core:
+        return False
+    core_noapos = core.replace("'", "")
+    # If any token signals personal / project / session state, bail —
+    # apostrophes stripped so "i'm"/"i've" tokenise to im/ive (stateful).
+    tokens = re.findall(r"[a-z]+", core_noapos)
+    if any(tok in _STATEFUL_SIGNALS for tok in tokens):
+        return False
+    if core in _TRIVIAL_GREETINGS:
+        return True
+    if _STATELESS_QUESTION_RE.match(core_noapos):
+        return True
+    return False
+
+
 def main():
     config = load_config()
 
@@ -522,6 +574,18 @@ def main():
         debug_log(config, f"Prompt is ack-only ({_ack_form!r}), skipping recall")
         return
 
+    # Switchroom Phase 6a (RFC hindsight-synthesis-layers.md) — skip recall
+    # on plausibly-stateless trivial asks (time/date/day, bare greetings)
+    # when `recallSkipTrivial` is on. Same conservatism as the ack-skip:
+    # a false negative (skipping a turn that DID need memory) costs the
+    # remember-across-sessions continuity, so `_is_trivial_stateless`
+    # bails the instant the prompt carries any personal/stateful signal
+    # (a pronoun, a memory verb, "project", etc.). It only skips an exact
+    # stateless form — never a content-classifier guess.
+    if config.get("recallSkipTrivial", True) and _is_trivial_stateless(_ack_form, _stripped):
+        debug_log(config, f"Prompt is trivial/stateless ({_ack_form!r}), skipping recall")
+        return
+
     session_id = hook_input.get("session_id") or ""
 
     # Switchroom #303 — push a "📚 recalling memories" status to the

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

@@ -0,0 +1,101 @@
+"""Switchroom Phase 6a — unit tests for recall.py's trivial-stateless skip.
+
+`_is_trivial_stateless` gates the auto-recall hook: it returns True only
+for prompts that provably never need user memory (current time/date/day,
+bare greetings), so the ~1-2s recall arm + ~1024 injected tokens are
+skipped on those turns. The load-bearing property is the NO-FALSE-NEGATIVE
+guarantee: a prompt that could need memory must never be skipped, because
+skipping it would breach the remember-across-sessions continuity job. The
+KEEP corpus below is that no-regression gate.
+
+Stdlib-only.
+"""
+
+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 recall import _is_trivial_stateless  # noqa: E402
+
+
+# Prompts that provably never need user/session memory — safe to skip.
+TRIVIAL = [
+    "what time is it",
+    "what time is it?",
+    "what time is it now",
+    "what's the time",
+    "time?",
+    "current time",
+    "what's the date",
+    "whats the date",
+    "what's today's date",
+    "what day is it",
+    "what day is it?",
+    "what day is it today",
+    "what day of the week is it",
+    "hi",
+    "hello",
+    "hey",
+    "hey there",
+    "good morning",
+    "morning",
+]
+
+# Prompts that depend on (or might depend on) stored user/project/session
+# state — must NEVER be skipped. This is the no-regression gate.
+NEEDS_MEMORY = [
+    "what host am I on?",          # reads trivial, but needs memory — the "i" trap
+    "what's my config",
+    "what was I frustrated about",
+    "remind me what we discussed",
+    "what's the date for my deadline",   # has 'my'
+    "what's the date of our last deploy",  # 'our'/'last'/'deploy'
+    "what projects do I have",
+    "do you remember my preference",
+    "what's the status of the deploy",
+    "summarize our last conversation",
+    "hello, can you check my open items",  # greeting + real ask
+    "what time did I say the meeting was",  # 'time' but 'i'/'say'
+    "what should I work on",
+    "tell me about the project",
+    "what's the weather",          # stateless-ish but not in the time/date set → recall anyway
+    "how do I fix this",
+]
+
+
+class TestTrivialStatelessSkip(unittest.TestCase):
+    def test_trivial_prompts_are_skipped(self):
+        for p in TRIVIAL:
+            with self.subTest(prompt=p):
+                self.assertTrue(
+                    _is_trivial_stateless("", p),
+                    f"expected trivial/stateless skip for {p!r}",
+                )
+
+    def test_memory_prompts_are_never_skipped(self):
+        # The critical safety invariant — zero false negatives.
+        for p in NEEDS_MEMORY:
+            with self.subTest(prompt=p):
+                self.assertFalse(
+                    _is_trivial_stateless("", p),
+                    f"FALSE NEGATIVE: would skip recall for {p!r} which may need memory",
+                )
+
+    def test_empty_and_whitespace_do_not_skip_here(self):
+        # The <5-char / empty guards live earlier in main(); the classifier
+        # itself returns False for empty so it never short-circuits oddly.
+        self.assertFalse(_is_trivial_stateless("", ""))
+        self.assertFalse(_is_trivial_stateless("", "   "))
+
+    def test_personal_pronoun_blocks_skip(self):
+        # Even a time question is kept the moment a stateful token appears.
+        self.assertTrue(_is_trivial_stateless("", "what time is it"))
+        self.assertFalse(_is_trivial_stateless("", "what time is it for my call"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/tests/test_config.py

@@ -42,7 +42,7 @@ class TestLoadConfig:
         cfg = load_config()
         assert cfg["autoRecall"] is True
         assert cfg["autoRetain"] is True
-        assert cfg["recallBudget"] == "mid"
+        assert cfg["recallBudget"] == "low"
         assert cfg["retainEveryNTurns"] == 10
 
     def test_settings_json_overrides_defaults(self, tmp_path, monkeypatch):
@@ -75,7 +75,7 @@ class TestLoadConfig:
         monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
         (tmp_path / "settings.json").write_text("not valid json{{")
         cfg = load_config()
-        assert cfg["recallBudget"] == "mid"  # default still applies
+        assert cfg["recallBudget"] == "low"  # default still applies
 
     def test_null_values_in_settings_json_not_applied(self, tmp_path, monkeypatch):
         monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
@@ -112,7 +112,7 @@ class TestLoadConfig:
         # HOME points to tmp_path where no .hindsight/claude-code.json exists
         monkeypatch.setenv("HOME", str(tmp_path))
         cfg = load_config()
-        assert cfg["recallBudget"] == "mid"  # default
+        assert cfg["recallBudget"] == "low"  # default
 
     def test_env_var_wins_over_user_config(self, tmp_path, monkeypatch):
         plugin_root = tmp_path / "plugin"