switchroom 0.14.0 → 0.14.2

package/telegram-plugin/tests/auth-snapshot-format.test.ts

@@ -15,11 +15,13 @@ import {
   renderFallbackAnnouncement,
   buildSnapshotKeyboard,
   buildSnapshotsFromState,
+  buildSnapshotsFromCachedState,
+  reviveLastQuota,
   THROTTLING_THRESHOLD_PCT,
   type AccountSnapshot,
 } from '../auth-snapshot-format.js';
 import type { QuotaUtilization } from '../quota-check.js';
-import type { ListStateData } from '../../src/auth/broker/client.js';
+import type { LastQuotaSnapshot, ListStateData } from '../../src/auth/broker/client.js';
 
 // Frozen "now" for all reset-time math. Friday May 15 2026 10:53 AM Melbourne
 // = 2026-05-15T00:53:00Z. Reset epochs in fixtures are in seconds.
@@ -406,6 +408,136 @@ describe('buildSnapshotsFromState', () => {
   });
 });
 
+// ── reviveLastQuota ──────────────────────────────────────────────────
+
+describe('reviveLastQuota', () => {
+  it('returns null for null input', () => {
+    expect(reviveLastQuota(null)).toBeNull();
+  });
+
+  it('returns null for undefined input', () => {
+    expect(reviveLastQuota(undefined)).toBeNull();
+  });
+
+  it('converts ISO-string dates to Date objects', () => {
+    const isoFive = '2026-05-15T06:00:00.000Z';
+    const isoSeven = '2026-05-22T06:00:00.000Z';
+    const lq: LastQuotaSnapshot = {
+      fiveHourUtilizationPct: 45,
+      sevenDayUtilizationPct: 72,
+      fiveHourResetAt: isoFive,
+      sevenDayResetAt: isoSeven,
+      representativeClaim: 'five_hour',
+      overageStatus: 'allowed',
+      overageDisabledReason: null,
+      capturedAt: Date.now(),
+    };
+    const q = reviveLastQuota(lq);
+    expect(q).not.toBeNull();
+    expect(q!.fiveHourUtilizationPct).toBe(45);
+    expect(q!.sevenDayUtilizationPct).toBe(72);
+    expect(q!.fiveHourResetAt).toBeInstanceOf(Date);
+    expect(q!.fiveHourResetAt!.toISOString()).toBe(isoFive);
+    expect(q!.sevenDayResetAt).toBeInstanceOf(Date);
+    expect(q!.sevenDayResetAt!.toISOString()).toBe(isoSeven);
+    expect(q!.representativeClaim).toBe('five_hour');
+    expect(q!.overageStatus).toBe('allowed');
+    expect(q!.overageDisabledReason).toBeNull();
+  });
+
+  it('passes through null dates as null', () => {
+    const lq: LastQuotaSnapshot = {
+      fiveHourUtilizationPct: 20,
+      sevenDayUtilizationPct: 30,
+      fiveHourResetAt: null,
+      sevenDayResetAt: null,
+      representativeClaim: null,
+      overageStatus: null,
+      overageDisabledReason: null,
+      capturedAt: Date.now(),
+    };
+    const q = reviveLastQuota(lq);
+    expect(q!.fiveHourResetAt).toBeNull();
+    expect(q!.sevenDayResetAt).toBeNull();
+  });
+});
+
+// ── buildSnapshotsFromCachedState ────────────────────────────────────
+
+describe('buildSnapshotsFromCachedState', () => {
+  function makeLastQuota(fivePct: number, sevenPct: number): LastQuotaSnapshot {
+    return {
+      fiveHourUtilizationPct: fivePct,
+      sevenDayUtilizationPct: sevenPct,
+      fiveHourResetAt: null,
+      sevenDayResetAt: null,
+      representativeClaim: null,
+      overageStatus: null,
+      overageDisabledReason: null,
+      capturedAt: Date.now(),
+    };
+  }
+
+  it('produces quota=null for accounts with no cached snapshot', () => {
+    const state: ListStateData = {
+      active: 'a@x',
+      fallback_order: [],
+      accounts: [{ label: 'a@x', exhausted: false, last_quota: null }],
+      agents: [],
+      consumers: [],
+    };
+    const snaps = buildSnapshotsFromCachedState(state);
+    expect(snaps[0]!.quota).toBeNull();
+    // classifyHealth on this snap returns 'unknown'
+    expect(snaps[0]!.quotaError).toContain('no cached quota');
+  });
+
+  it('revives cached utilization into Date-bearing QuotaUtilization', () => {
+    const state: ListStateData = {
+      active: 'b@x',
+      fallback_order: [],
+      accounts: [
+        { label: 'a@x', exhausted: false, last_quota: makeLastQuota(20, 30) },
+        { label: 'b@x', exhausted: false, last_quota: makeLastQuota(85, 40) },
+      ],
+      agents: [],
+      consumers: [],
+    };
+    const snaps = buildSnapshotsFromCachedState(state);
+    expect(snaps[0]!.quota?.fiveHourUtilizationPct).toBe(20);
+    expect(snaps[1]!.quota?.sevenDayUtilizationPct).toBe(40);
+    expect(snaps[1]!.isActive).toBe(true);
+  });
+
+  it('classifyHealth correctly classifies cached throttling account (≥80% threshold)', () => {
+    const state: ListStateData = {
+      active: 'a@x',
+      fallback_order: [],
+      accounts: [
+        { label: 'a@x', exhausted: false, last_quota: makeLastQuota(85, 40) },
+      ],
+      agents: [],
+      consumers: [],
+    };
+    const snaps = buildSnapshotsFromCachedState(state);
+    // With cached 85% 5h utilization, classifyHealth should return 'throttling'
+    expect(classifyHealth(snaps[0]!)).toBe('throttling');
+  });
+
+  it('treats absent last_quota (undefined) the same as null', () => {
+    const state: ListStateData = {
+      active: 'a@x',
+      fallback_order: [],
+      // last_quota absent — simulates old broker version / cold broker start
+      accounts: [{ label: 'a@x', exhausted: false }],
+      agents: [],
+      consumers: [],
+    };
+    const snaps = buildSnapshotsFromCachedState(state);
+    expect(snaps[0]!.quota).toBeNull();
+  });
+});
+
 // ── recommendation logic edge cases ──────────────────────────────────
 
 describe('recommendation', () => {

package/telegram-plugin/tests/boot-card-render.test.ts

@@ -364,3 +364,96 @@ describe('renderBootCard — resolved / snooze rendering', () => {
     expect(out).toContain('✅ <b>Broker</b>  resolved')
   })
 })
+
+// ── Config-change row rendering (E3) ─────────────────────────────────────────
+
+describe('renderBootCard — configChanges rows', () => {
+  it('silent when configChanges is absent', () => {
+    const out = renderBootCard({ agentName: 'k', version: 'v' })
+    expect(out).toBe('✅ <b>k</b> back up · v')
+    expect(out).not.toContain('Config')
+  })
+
+  it('silent when configChanges is empty array', () => {
+    const out = renderBootCard({ agentName: 'k', version: 'v', configChanges: [] })
+    expect(out).toBe('✅ <b>k</b> back up · v')
+    expect(out).not.toContain('Config')
+  })
+
+  it('renders a model-change row when model changed', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      configChanges: [{ field: 'model', from: 'claude-opus-4', to: 'claude-sonnet-4-5' }],
+    })
+    expect(out).toContain('⚙️ <b>Config</b>')
+    expect(out).toContain('claude-opus-4')
+    expect(out).toContain('claude-sonnet-4-5')
+    expect(out).toContain('→')
+  })
+
+  it('renders a coarse tools-changed row for tools diff', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      configChanges: [{ field: 'tools', from: 'aaa', to: 'bbb' }],
+    })
+    expect(out).toContain('tools allowlist changed')
+    expect(out).toContain('/status')
+    expect(out).not.toContain('aaa')
+    expect(out).not.toContain('bbb')
+  })
+
+  it('renders a coarse skills-changed row for skills diff', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      configChanges: [{ field: 'skills', from: 'ccc', to: 'ddd' }],
+    })
+    expect(out).toContain('skills changed')
+    expect(out).toContain('/status')
+  })
+
+  it('renders multiple config-change rows (all four fields)', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      configChanges: [
+        { field: 'model', from: 'claude-opus-4', to: 'claude-sonnet-4-5' },
+        { field: 'tools', from: 'abc', to: 'def' },
+        { field: 'skills', from: 'ghi', to: 'jkl' },
+        { field: 'memoryBackend', from: 'finn', to: 'finn-v2' },
+      ],
+    })
+    const lines = out.split('\n')
+    // Should have more than 1 line (ack + separator + config rows).
+    expect(lines.length).toBeGreaterThan(2)
+    expect(out).toContain('claude-opus-4')
+    expect(out).toContain('tools allowlist changed')
+    expect(out).toContain('skills changed')
+    expect(out).toContain('finn')
+    expect(out).toContain('finn-v2')
+  })
+
+  it('config-change rows appear after probe rows', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      probes: {
+        broker: { status: 'fail', label: 'Broker', detail: 'socket missing' },
+      },
+      configChanges: [{ field: 'model', from: 'a', to: 'b' }],
+    })
+    const brokerIdx = out.indexOf('Broker')
+    const configIdx = out.indexOf('Config')
+    expect(brokerIdx).toBeGreaterThan(-1)
+    expect(configIdx).toBeGreaterThan(-1)
+    expect(configIdx).toBeGreaterThan(brokerIdx)
+  })
+
+  it('bare ack still returned when configChanges fires but produces only empty rows (defensive)', () => {
+    // Edge: empty configChanges array passed → should not produce rows.
+    const out = renderBootCard({ agentName: 'k', version: 'v', configChanges: [] })
+    expect(out).toBe('✅ <b>k</b> back up · v')
+  })
+})

package/telegram-plugin/tests/config-snapshot.test.ts

@@ -0,0 +1,409 @@
+/**
+ * Unit tests for the config-snapshot module (config-snapshot.ts).
+ *
+ * Covers:
+ *   1. captureConfigSnapshot — field normalization, null handling
+ *   2. diffSnapshots — model changed only; tools changed only; everything
+ *      changed; nothing changed; first boot (previous=null)
+ *   3. renderConfigChangeDim — verbatim for model/memory, coarse for tools/skills
+ *   4. loadSnapshot / persistSnapshot — round-trip, corrupt file, first boot
+ *   5. hashStringArray — deterministic, order-independent, null/empty handling
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, existsSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+
+import {
+  captureConfigSnapshot,
+  diffSnapshots,
+  renderConfigChangeDim,
+  hashStringArray,
+  normalizeModel,
+  loadSnapshot,
+  persistSnapshot,
+  type ConfigSnapshot,
+  type ConfigDiff,
+} from '../gateway/config-snapshot.js'
+
+let tmp: string
+beforeEach(() => { tmp = mkdtempSync(join(tmpdir(), 'cfg-snap-')) })
+afterEach(() => { rmSync(tmp, { recursive: true, force: true }) })
+
+// ── hashStringArray ───────────────────────────────────────────────────────────
+
+describe('hashStringArray', () => {
+  it('returns null for null input', () => {
+    expect(hashStringArray(null)).toBeNull()
+  })
+
+  it('returns null for empty array', () => {
+    expect(hashStringArray([])).toBeNull()
+  })
+
+  it('returns a 12-char hex string for a non-empty array', () => {
+    const h = hashStringArray(['bash', 'computer'])
+    expect(typeof h).toBe('string')
+    expect(h!.length).toBe(12)
+    expect(/^[0-9a-f]{12}$/.test(h!)).toBe(true)
+  })
+
+  it('is order-independent — sorted before hashing', () => {
+    const h1 = hashStringArray(['bash', 'computer', 'str_replace_based_edit_tool'])
+    const h2 = hashStringArray(['str_replace_based_edit_tool', 'bash', 'computer'])
+    expect(h1).toBe(h2)
+  })
+
+  it('produces different hashes for different content', () => {
+    const h1 = hashStringArray(['bash'])
+    const h2 = hashStringArray(['computer'])
+    expect(h1).not.toBe(h2)
+  })
+})
+
+// ── normalizeModel ────────────────────────────────────────────────────────────
+
+describe('normalizeModel', () => {
+  it('lowercases the model string', () => {
+    expect(normalizeModel('Claude-Sonnet-4-5')).toBe('claude-sonnet-4-5')
+  })
+
+  it('trims whitespace', () => {
+    expect(normalizeModel('  claude-opus-4  ')).toBe('claude-opus-4')
+  })
+
+  it('returns null for null, undefined, or empty string', () => {
+    expect(normalizeModel(null)).toBeNull()
+    expect(normalizeModel(undefined)).toBeNull()
+    expect(normalizeModel('')).toBeNull()
+    expect(normalizeModel('   ')).toBeNull()
+  })
+})
+
+// ── captureConfigSnapshot ────────────────────────────────────────────────────
+
+describe('captureConfigSnapshot', () => {
+  it('captures all fields from config', () => {
+    const snap = captureConfigSnapshot({
+      agentName: 'finn',
+      model: 'claude-sonnet-4-5',
+      toolsAllow: ['bash', 'computer'],
+      skills: ['search'],
+      memoryCollection: 'finn-memories',
+      now: () => 1000,
+    })
+    expect(snap.schema).toBe(1)
+    expect(snap.capturedAtMs).toBe(1000)
+    expect(snap.model).toBe('claude-sonnet-4-5')
+    expect(snap.toolsHash).not.toBeNull()
+    expect(snap.skillsHash).not.toBeNull()
+    expect(snap.memoryBackend).toBe('finn-memories')
+  })
+
+  it('produces null fields when config fields are absent', () => {
+    const snap = captureConfigSnapshot({ agentName: 'finn' })
+    expect(snap.model).toBeNull()
+    expect(snap.toolsHash).toBeNull()
+    expect(snap.skillsHash).toBeNull()
+    expect(snap.memoryBackend).toBeNull()
+  })
+
+  it('normalizes model to lowercase', () => {
+    const snap = captureConfigSnapshot({ agentName: 'finn', model: 'Claude-Sonnet-4-5' })
+    expect(snap.model).toBe('claude-sonnet-4-5')
+  })
+
+  it('tools hash is order-independent', () => {
+    const a = captureConfigSnapshot({ agentName: 'x', toolsAllow: ['bash', 'computer'] })
+    const b = captureConfigSnapshot({ agentName: 'x', toolsAllow: ['computer', 'bash'] })
+    expect(a.toolsHash).toBe(b.toolsHash)
+  })
+})
+
+// ── diffSnapshots ─────────────────────────────────────────────────────────────
+
+function makeSnap(overrides: Partial<ConfigSnapshot> = {}): ConfigSnapshot {
+  return {
+    schema: 1,
+    capturedAtMs: 1000,
+    model: 'claude-sonnet-4-5',
+    toolsHash: hashStringArray(['bash', 'computer']),
+    skillsHash: hashStringArray(['search']),
+    memoryBackend: 'finn',
+    ...overrides,
+  }
+}
+
+describe('diffSnapshots', () => {
+  it('returns empty diff when previous is null (first boot)', () => {
+    const current = makeSnap()
+    expect(diffSnapshots(current, null)).toEqual([])
+  })
+
+  it('returns empty diff when nothing changed', () => {
+    const snap = makeSnap()
+    expect(diffSnapshots(snap, snap)).toEqual([])
+  })
+
+  it('detects model change only', () => {
+    const prev = makeSnap({ model: 'claude-opus-4' })
+    const curr = makeSnap({ model: 'claude-sonnet-4-5' })
+    const diff = diffSnapshots(curr, prev)
+    expect(diff).toHaveLength(1)
+    expect(diff[0].field).toBe('model')
+    expect(diff[0].from).toBe('claude-opus-4')
+    expect(diff[0].to).toBe('claude-sonnet-4-5')
+  })
+
+  it('detects tools allowlist change only', () => {
+    const prevHash = hashStringArray(['bash'])
+    const currHash = hashStringArray(['bash', 'computer'])
+    const prev = makeSnap({ toolsHash: prevHash })
+    const curr = makeSnap({ toolsHash: currHash })
+    const diff = diffSnapshots(curr, prev)
+    expect(diff).toHaveLength(1)
+    expect(diff[0].field).toBe('tools')
+  })
+
+  it('detects skills change only', () => {
+    const prev = makeSnap({ skillsHash: hashStringArray(['search']) })
+    const curr = makeSnap({ skillsHash: hashStringArray(['search', 'code']) })
+    const diff = diffSnapshots(curr, prev)
+    expect(diff).toHaveLength(1)
+    expect(diff[0].field).toBe('skills')
+  })
+
+  it('detects memory backend change only', () => {
+    const prev = makeSnap({ memoryBackend: 'finn' })
+    const curr = makeSnap({ memoryBackend: 'finn-v2' })
+    const diff = diffSnapshots(curr, prev)
+    expect(diff).toHaveLength(1)
+    expect(diff[0].field).toBe('memoryBackend')
+    expect(diff[0].from).toBe('finn')
+    expect(diff[0].to).toBe('finn-v2')
+  })
+
+  it('detects all four fields changing at once', () => {
+    const prev = makeSnap({
+      model: 'claude-opus-4',
+      toolsHash: hashStringArray(['bash']),
+      skillsHash: hashStringArray(['search']),
+      memoryBackend: 'old-bank',
+    })
+    const curr = makeSnap({
+      model: 'claude-sonnet-4-5',
+      toolsHash: hashStringArray(['bash', 'computer']),
+      skillsHash: hashStringArray(['search', 'code']),
+      memoryBackend: 'new-bank',
+    })
+    const diff = diffSnapshots(curr, prev)
+    expect(diff).toHaveLength(4)
+    const fields = diff.map(d => d.field)
+    expect(fields).toContain('model')
+    expect(fields).toContain('tools')
+    expect(fields).toContain('skills')
+    expect(fields).toContain('memoryBackend')
+  })
+
+  it('does not fire when both sides have null for the same field', () => {
+    const prev = makeSnap({ model: null })
+    const curr = makeSnap({ model: null })
+    const diff = diffSnapshots(curr, prev)
+    const modelDiff = diff.find(d => d.field === 'model')
+    expect(modelDiff).toBeUndefined()
+  })
+
+  it('fires when model transitions from null to a value (first explicit model set)', () => {
+    const prev = makeSnap({ model: null })
+    const curr = makeSnap({ model: 'claude-sonnet-4-5' })
+    const diff = diffSnapshots(curr, prev)
+    const modelDiff = diff.find(d => d.field === 'model')
+    expect(modelDiff).toBeDefined()
+    expect(modelDiff!.from).toBeNull()
+    expect(modelDiff!.to).toBe('claude-sonnet-4-5')
+  })
+})
+
+// ── renderConfigChangeDim ─────────────────────────────────────────────────────
+
+describe('renderConfigChangeDim', () => {
+  it('model: shows verbatim from → to', () => {
+    const row = renderConfigChangeDim({
+      field: 'model',
+      from: 'claude-opus-4',
+      to: 'claude-sonnet-4-5',
+    })
+    expect(row).toContain('claude-opus-4')
+    expect(row).toContain('claude-sonnet-4-5')
+    expect(row).toContain('→')
+    expect(row).toContain('model:')
+  })
+
+  it('model: shows "(default)" when from or to is null', () => {
+    const row = renderConfigChangeDim({ field: 'model', from: null, to: 'claude-sonnet-4-5' })
+    expect(row).toContain('(default)')
+    expect(row).toContain('claude-sonnet-4-5')
+  })
+
+  it('memoryBackend: shows verbatim from → to', () => {
+    const row = renderConfigChangeDim({
+      field: 'memoryBackend',
+      from: 'finn',
+      to: 'finn-v2',
+    })
+    expect(row).toContain('finn')
+    expect(row).toContain('finn-v2')
+    expect(row).toContain('memory backend:')
+  })
+
+  it('tools: coarse message with /status hint', () => {
+    const row = renderConfigChangeDim({
+      field: 'tools',
+      from: 'abc123',
+      to: 'def456',
+    })
+    expect(row).toContain('tools allowlist changed')
+    expect(row).toContain('/status')
+    // Should NOT contain raw hashes in the user-facing text.
+    expect(row).not.toContain('abc123')
+    expect(row).not.toContain('def456')
+  })
+
+  it('skills: coarse message with /status hint', () => {
+    const row = renderConfigChangeDim({
+      field: 'skills',
+      from: 'abc123',
+      to: 'def456',
+    })
+    expect(row).toContain('skills changed')
+    expect(row).toContain('/status')
+  })
+
+  it('all rows start with the ⚙️ Config prefix', () => {
+    const fields: Array<ConfigDiff[number]['field']> = ['model', 'tools', 'skills', 'memoryBackend']
+    for (const field of fields) {
+      const row = renderConfigChangeDim({ field, from: 'a', to: 'b' })
+      expect(row).toContain('⚙️')
+      expect(row).toContain('<b>Config</b>')
+    }
+  })
+})
+
+// ── loadSnapshot / persistSnapshot ───────────────────────────────────────────
+
+describe('loadSnapshot / persistSnapshot — persistence', () => {
+  it('returns null when file does not exist (first boot)', () => {
+    const path = join(tmp, 'snap.json')
+    expect(loadSnapshot(path)).toBeNull()
+  })
+
+  it('round-trips: persist then load yields the same snapshot', () => {
+    const path = join(tmp, 'snap.json')
+    const snap = makeSnap({ capturedAtMs: 9999 })
+    persistSnapshot(path, snap)
+    expect(existsSync(path)).toBe(true)
+    const loaded = loadSnapshot(path)
+    expect(loaded).not.toBeNull()
+    expect(loaded!.model).toBe(snap.model)
+    expect(loaded!.toolsHash).toBe(snap.toolsHash)
+    expect(loaded!.skillsHash).toBe(snap.skillsHash)
+    expect(loaded!.memoryBackend).toBe(snap.memoryBackend)
+    expect(loaded!.capturedAtMs).toBe(9999)
+  })
+
+  it('corrupt JSON file is renamed aside and null is returned', () => {
+    const path = join(tmp, 'snap.json')
+    writeFileSync(path, 'not-valid-json-{{{')
+    const loaded = loadSnapshot(path, () => 55555)
+    expect(loaded).toBeNull()
+    // Corrupt file preserved with timestamp suffix.
+    expect(existsSync(`${path}.corrupt-55555`)).toBe(true)
+  })
+
+  it('schema mismatch returns null', () => {
+    const path = join(tmp, 'snap.json')
+    writeFileSync(path, JSON.stringify({ schema: 99, capturedAtMs: 1, model: null, toolsHash: null, skillsHash: null, memoryBackend: null }))
+    expect(loadSnapshot(path)).toBeNull()
+  })
+
+  it('persists and overwrites on subsequent calls (baseline update)', () => {
+    const path = join(tmp, 'snap.json')
+    const first = makeSnap({ model: 'claude-opus-4' })
+    const second = makeSnap({ model: 'claude-sonnet-4-5' })
+    persistSnapshot(path, first)
+    persistSnapshot(path, second)
+    const loaded = loadSnapshot(path)
+    expect(loaded!.model).toBe('claude-sonnet-4-5')
+  })
+})
+
+// ── Integration: full boot-to-boot lifecycle ──────────────────────────────────
+
+describe('boot-to-boot lifecycle', () => {
+  it('first boot: no diff; subsequent boot with same config: no diff', () => {
+    const path = join(tmp, 'snap.json')
+    const snap1 = captureConfigSnapshot({
+      agentName: 'finn',
+      model: 'claude-sonnet-4-5',
+      toolsAllow: ['bash'],
+      skills: ['search'],
+      memoryCollection: 'finn',
+      now: () => 1000,
+    })
+
+    // First boot: no prior snapshot → no diff.
+    const prev1 = loadSnapshot(path)
+    const diff1 = diffSnapshots(snap1, prev1)
+    expect(diff1).toEqual([])
+    persistSnapshot(path, snap1)
+
+    // Second boot with SAME config → no diff.
+    const snap2 = captureConfigSnapshot({
+      agentName: 'finn',
+      model: 'claude-sonnet-4-5',
+      toolsAllow: ['bash'],
+      skills: ['search'],
+      memoryCollection: 'finn',
+      now: () => 2000,
+    })
+    const prev2 = loadSnapshot(path)
+    const diff2 = diffSnapshots(snap2, prev2)
+    expect(diff2).toEqual([])
+    persistSnapshot(path, snap2)
+  })
+
+  it('third boot after model change: diff fires once, then silent again', () => {
+    const path = join(tmp, 'snap.json')
+
+    // Boot 1: snapshot with old model.
+    const snap1 = captureConfigSnapshot({
+      agentName: 'finn',
+      model: 'claude-opus-4',
+      now: () => 1000,
+    })
+    persistSnapshot(path, snap1)
+
+    // Boot 2: model changed.
+    const snap2 = captureConfigSnapshot({
+      agentName: 'finn',
+      model: 'claude-sonnet-4-5',
+      now: () => 2000,
+    })
+    const prev2 = loadSnapshot(path)
+    const diff2 = diffSnapshots(snap2, prev2)
+    expect(diff2).toHaveLength(1)
+    expect(diff2[0].field).toBe('model')
+    persistSnapshot(path, snap2)
+
+    // Boot 3: same model as boot 2 → no diff.
+    const snap3 = captureConfigSnapshot({
+      agentName: 'finn',
+      model: 'claude-sonnet-4-5',
+      now: () => 3000,
+    })
+    const prev3 = loadSnapshot(path)
+    const diff3 = diffSnapshots(snap3, prev3)
+    expect(diff3).toEqual([])
+  })
+})

package/telegram-plugin/tests/operator-events.test.ts

@@ -177,23 +177,29 @@ describe('renderOperatorEvent — credentials-invalid', () => {
 })
 
 describe('renderOperatorEvent — credit-exhausted', () => {
-  it('offers swap + add slot buttons', () => {
+  it('shows credit balance text with /auth use hint and no stub buttons (E5)', () => {
     const { text, keyboard } = renderOperatorEvent(makeEvent('credit-exhausted'))
     expect(text).toContain('Credit balance')
+    expect(text).toContain('/auth use')
     const buttons = keyboard.inline_keyboard.flat()
-    expect(buttons.some(b => b.callback_data?.includes('swap-slot'))).toBe(true)
-    expect(buttons.some(b => b.callback_data?.includes('add-slot'))).toBe(true)
+    // swap-slot and add-slot buttons removed (E5 — they redirected to terminal)
+    expect(buttons.some(b => b.callback_data?.includes('swap-slot'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('add-slot'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('dismiss'))).toBe(true)
   })
 })
 
 describe('renderOperatorEvent — quota-exhausted', () => {
-  it('renders quota text + swap/add buttons', () => {
+  it('renders quota text with /auth use hint and no stub buttons (E5)', () => {
     const { text, keyboard } = renderOperatorEvent(makeEvent('quota-exhausted'))
     expect(text).toContain('Quota exhausted')
     expect(text).toContain('<b>gymbro</b>')
+    expect(text).toContain('/auth use')
     const buttons = keyboard.inline_keyboard.flat()
-    expect(buttons.some(b => b.callback_data?.includes('swap-slot'))).toBe(true)
-    expect(buttons.some(b => b.callback_data?.includes('add-slot'))).toBe(true)
+    // swap-slot and add-slot buttons removed (E5 — they redirected to terminal)
+    expect(buttons.some(b => b.callback_data?.includes('swap-slot'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('add-slot'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('dismiss'))).toBe(true)
   })
 
   it('contains auto-fallback slot info in detail when provided', () => {