dsh-memu-memory 1.1.2 → 1.2.0

package/tests/settings-beat.test.mjs

@@ -0,0 +1,221 @@
+// Task E: the settings pane used to hear only about writes made in this document,
+// and only through a manual reload after a tool call or another window changed
+// something. It now shares the sidebar's heartbeat — poll a two-field marker,
+// refetch only when it moves, send nothing while hidden — and wakes immediately
+// on the cross-window channel without echoing back. These cases drive the real
+// SettingsPage with a fake hook runtime.
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+const registrations = []
+
+function makeElement(type, props, ...children) {
+  return { type, props: { ...(props || {}), children: children.length <= 1 ? children[0] : children } }
+}
+
+let hooks = []
+let cursor = 0
+let effects = []
+
+const React = {
+  createElement: makeElement,
+  Fragment: Symbol('Fragment'),
+  useState(initial) {
+    const index = cursor++
+    if (hooks[index] === undefined) hooks[index] = typeof initial === "function" ? initial() : initial
+    return [hooks[index], (next) => { hooks[index] = typeof next === "function" ? next(hooks[index]) : next }]
+  },
+  useCallback: (fn) => fn,
+  useMemo: (fn) => fn(),
+  useEffect(fn, deps) { effects.push({ fn, deps }) },
+  useLayoutEffect() {},
+  useRef: (value) => ({ current: value }),
+  useSyncExternalStore: (_subscribe, getSnapshot) => getSnapshot(),
+}
+
+const intervals = []
+globalThis.setInterval = (fn, ms) => { intervals.push({ fn, ms }); return intervals.length }
+globalThis.clearInterval = () => {}
+
+const visibilityListeners = new Set()
+globalThis.document = {
+  visibilityState: 'visible',
+  addEventListener(name, fn) { if (name === "visibilitychange") visibilityListeners.add(fn) },
+  removeEventListener(name, fn) { if (name === "visibilitychange") visibilityListeners.delete(fn) },
+  createElement: () => ({ style: {}, setAttribute() {}, appendChild() {}, remove() {}, click() {} }),
+  querySelector: () => null,
+  head: { appendChild() {} },
+  body: { appendChild() {} },
+}
+
+// The channel is how another document announces a write. The fake records posts so
+// the test can prove an inbound message is never re-announced.
+const channels = []
+class FakeChannel {
+  constructor(name) { this.name = name; this.posted = []; channels.push(this) }
+  postMessage(data) { this.posted.push(data) }
+  unref() {}
+  close() {}
+}
+globalThis.BroadcastChannel = FakeChannel
+
+globalThis.window = {
+  __ModuleLoader__: {
+    load({ factory }) {
+      globalThis.__dshMemuExports = factory((name) => {
+        if (name === "react") return React
+        throw new Error("unexpected require: " + name)
+      })
+    },
+  },
+  addEventListener() {},
+  removeEventListener() {},
+}
+
+await import('../lib/client.js')
+
+function makeSettingsState(server) {
+  return {
+    engine: { status: 'ready', versions: [], currentVersion: '0.11.0b3', recommendedVersion: '0.11.0b3', installed: true, state: {} },
+    settings: { autoInject: 'smart', memoryBackend: 'agent', libraries: [] },
+    memuConfig: { provider: 'openai' },
+    summaryConfig: {},
+    libraries: [],
+    archivedLibraries: [],
+    revision: server.revision,
+    stamp: server.stamp,
+  }
+}
+
+function makeCtx() {
+  const calls = []
+  const server = { revision: 1, stamp: 'state:10:1' }
+  const call = async (_path, endpoint, payload) => {
+    calls.push({ endpoint, payload })
+    if (endpoint === 'getSettingsState') return { ok: true, value: makeSettingsState(server) }
+    if (endpoint === 'getSidebarState') {
+      if (payload?.revisionOnly === true) return { ok: true, value: { revision: server.revision, stamp: server.stamp } }
+      return { ok: true, value: {} }
+    }
+    return { ok: true, value: {} }
+  }
+  const ctx = {
+    effect: (fn) => { try { fn() } catch {} },
+    locale: { register: () => () => {}, bind: () => (key) => key, get: () => 'zh' },
+    connection: { rpc: { call } },
+    sessions: { list: { subscribe: () => () => {}, getSnapshot: () => ({ byId: {}, ids: [] }) } },
+    get: () => undefined,
+    slots: { inject: (_name, callback) => callback({}), register: (spec, component) => { registrations.push({ spec, component }); return () => {} } },
+    inject: (_deps, callback) => callback({
+      effect: (fn) => { try { fn() } catch {} },
+      sidebarRightTabs: { register: () => () => {} },
+      get: () => undefined,
+    }),
+  }
+  return { ctx, calls, server }
+}
+
+const tick = async (times = 4) => {
+  for (let i = 0; i < times; i++) await new Promise((resolve) => setTimeout(resolve, 0))
+}
+const settingsCalls = (calls) => calls.filter((c) => c.endpoint === 'getSettingsState')
+const beatCalls = (calls) => calls.filter((c) => c.endpoint === 'getSidebarState')
+
+async function paintSettings(api = globalThis.__dshMemuExports) {
+  hooks = []
+  cursor = 0
+  effects = []
+  intervals.length = 0
+  visibilityListeners.clear()
+  registrations.length = 0
+  const harness = makeCtx()
+  api.apply(harness.ctx)
+  const registration = registrations.filter((r) => r.spec?.name === 'settings.section').at(-1)
+  assert.ok(registration?.component, 'the settings section was not registered')
+  const tree = registration.component({ ctx: harness.ctx, t: (key) => key })
+  assert.ok(tree, 'the settings page rendered nothing')
+  for (const effect of effects.slice()) effect.fn()
+  await tick()
+  return { ...harness, tree }
+}
+
+test('the settings pane arms one heartbeat and seeds it from its first paint', async () => {
+  const page = await paintSettings()
+  assert.equal(settingsCalls(page.calls).length, 1, 'the first paint is one fetch')
+  assert.equal(intervals.length, 1, 'exactly one heartbeat interval is armed on the settings page')
+  assert.ok(intervals[0].ms > 0 && intervals[0].ms <= 5000, 'the beat is seconds apart, not minutes')
+  assert.equal(visibilityListeners.size, 1, 'returning to the window is listened for')
+
+  // The first beat must compare against the revision/stamp that came with the
+  // paint. If the paint did not seed the marker, this would refetch needlessly.
+  await intervals[0].fn()
+  await tick()
+  assert.equal(beatCalls(page.calls).length, 1, 'one cheap beat was sent')
+  assert.equal(settingsCalls(page.calls).length, 1, 'an unchanged marker does not refetch')
+  const beat = beatCalls(page.calls).at(-1)
+  assert.deepEqual(Object.keys(beat.payload).sort(), ['revisionOnly'], 'the beat stays a bare marker')
+})
+
+test('a settings write from another window lands within one beat', async () => {
+  const page = await paintSettings()
+  // Exactly what an out-of-process write looks like here: settings live in
+  // state.json, so only the on-disk stamp moves; this process's counter stands still.
+  page.server.stamp = 'state:11:1'
+  await intervals[0].fn()
+  await tick()
+  assert.equal(page.server.revision, 1, 'the in-process counter deliberately did not move')
+  assert.equal(settingsCalls(page.calls).length, 2, 'the stamp alone must trigger a refetch')
+})
+
+test('a channel message wakes the pane immediately and is never echoed back', async () => {
+  const page = await paintSettings()
+  const channel = channels.at(-1)
+  assert.ok(channel, 'the client listens on the shared channel')
+
+  channel.onmessage({ data: { type: 'memory-write', kind: 'settings', libraryId: null, at: new Date().toISOString() } })
+  await tick()
+  assert.equal(settingsCalls(page.calls).length, 2, 'an announced write refetches without waiting for a beat')
+  assert.equal(channel.posted.length, 0, 'the receiver must not announce the write again')
+})
+
+test('a hidden pane sends no beats, and coming back refetches once', async () => {
+  const page = await paintSettings()
+  await intervals[0].fn()
+  await tick()
+  assert.equal(beatCalls(page.calls).length, 1, 'the visible pane polls')
+
+  globalThis.document.visibilityState = 'hidden'
+  await intervals[0].fn()
+  await tick()
+  assert.equal(beatCalls(page.calls).length, 1, 'a hidden pane sends no beats at all')
+  for (const listener of visibilityListeners) listener()
+  await tick()
+  assert.equal(settingsCalls(page.calls).length, 1, 'a hidden pane does not refetch on the event either')
+
+  globalThis.document.visibilityState = 'visible'
+  for (const listener of visibilityListeners) listener()
+  await tick()
+  assert.equal(settingsCalls(page.calls).length, 2, 'returning to the window refetches')
+})
+
+test('without BroadcastChannel the heartbeat alone keeps the pane honest', async () => {
+  // Host differences are not defects: a blocked channel must degrade to the beat,
+  // not throw or silently stop syncing (TASKS E, acceptance 3).
+  const saved = globalThis.BroadcastChannel
+  const savedApi = globalThis.__dshMemuExports
+  try {
+    globalThis.BroadcastChannel = undefined
+    await import('../lib/client.js?nochannel')
+    const api = globalThis.__dshMemuExports
+    assert.notEqual(api, savedApi, 'a fresh module instance was loaded')
+
+    const page = await paintSettings(api)
+    page.server.stamp = 'state:12:1'
+    await intervals[0].fn()
+    await tick()
+    assert.equal(settingsCalls(page.calls).length, 2, 'the beat still hears the write')
+  } finally {
+    globalThis.BroadcastChannel = saved
+    globalThis.__dshMemuExports = savedApi
+  }
+})

package/tests/short-term.test.mjs

@@ -0,0 +1,166 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-short-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+const memory = await import('../lib/memory.js')
+const inject = await import('../lib/inject.js')
+const privateMod = await import('../lib/private.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+function execFor(sessionId, cwd) {
+  return { agent: { session: { header: { id: sessionId, cwd, agentPreset: 'coding' } } } }
+}
+
+function rewindDeadline(libraryId, id, ms = 60_000) {
+  const index = state.loadPrivateIndex(libraryId)
+  index.entries[id].expiresAt = new Date(Date.now() - ms).toISOString()
+  state.savePrivateIndex(libraryId, index)
+}
+
+test('short_term writes carry a deadline, and the sweep expires them instead of deleting', async () => {
+  const cwd = path.join(home, 'proj-ttl')
+  const sessionId = 'short-ttl'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+
+  const { id, entry } = await memory.privateRemember({
+    exec,
+    content: 'Staging token rotation is due Friday.',
+    title: 'staging token rotation',
+    layer: 'short_term',
+  })
+  assert.equal(entry.layer, 'short_term')
+  const hours = (Date.parse(entry.expiresAt) - Date.now()) / 3_600_000
+  assert.ok(hours > 71 && hours <= 72, `expected a ~72h deadline, got ${hours}`)
+
+  rewindDeadline(binding.libraryId, id)
+  const sweep = memory.expireShortTerm()
+  assert.ok(sweep.expired.some((row) => row.id === id), 'the sweep must pick up the past-due entry')
+
+  const after = state.loadPrivateIndex(binding.libraryId).entries[id]
+  assert.equal(after.status, 'expired')
+  assert.ok(after.content.includes('Staging token rotation'), 'the body survives — promotion is still possible from the archive view')
+})
+
+test('an expired short_term entry leaves the anchor and the recall path', async () => {
+  const cwd = path.join(home, 'proj-gone')
+  const sessionId = 'short-gone'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+
+  const { id } = await memory.privateRemember({
+    exec,
+    content: 'The migration checklist lives in docs/migrate.md.',
+    title: 'migration checklist',
+    layer: 'short_term',
+  })
+  const before = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  assert.ok(before.pointerIds.includes(id))
+  const recalled = await memory.privateRecall({ exec, query: 'migration checklist', topK: 5 })
+  assert.ok(recalled.files.some((file) => file.name === id))
+
+  // Expired by the clock alone, before any sweep has run: the deadline itself has
+  // to be authoritative, otherwise a dead draft rides along for up to five minutes.
+  rewindDeadline(binding.libraryId, id, 1_000)
+  const after = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  assert.equal(after.pointerIds.includes(id), false)
+  assert.equal(after.text.includes(id), false)
+  const recalledAgain = await memory.privateRecall({ exec, query: 'migration checklist', topK: 5 })
+  assert.equal(recalledAgain.files.some((file) => file.name === id), false)
+})
+
+test('the anchor shows short_term as a pointer card, never as body text', async () => {
+  const cwd = path.join(home, 'proj-card')
+  const sessionId = 'short-card'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+
+  const { id } = await memory.privateRemember({
+    exec,
+    content: 'BODY-MARKER: the whole argument about the pricing page, in detail.',
+    title: 'pricing thread',
+    layer: 'short_term',
+  })
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 700 })
+  assert.ok(anchor.text.includes('[recent · short_term]'))
+  assert.ok(anchor.text.includes(`[${id}]`))
+  assert.ok(anchor.text.includes('pricing thread'))
+  assert.ok(anchor.text.includes('小时后过期'))
+  assert.equal(anchor.text.includes('BODY-MARKER'), false, 'switching conversations must not inject the previous conversation')
+  // A pointer is not content, so it must not be marked as already injected: that
+  // would suppress the first real recall of a memory the model was only told about.
+  assert.equal(anchor.ids.includes(id), false)
+})
+
+test('promoting a short_term draft clears its deadline; must_remember stays out of update', async () => {
+  const cwd = path.join(home, 'proj-promote')
+  const sessionId = 'short-promote'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+
+  const { id } = await memory.privateRemember({
+    exec,
+    content: 'He said the anniversary matters more than the launch date.',
+    title: 'anniversary over launch',
+    layer: 'short_term',
+  })
+  const promoted = await memory.privateUpdate({ exec, id, layer: 'long_term' })
+  assert.equal(promoted.entry.layer, 'long_term')
+  assert.equal(promoted.entry.expiresAt, undefined)
+  assert.equal(promoted.entry.promotedFrom, 'short_term')
+  assert.equal(promoted.entry.status, 'active')
+
+  rewindDeadline(binding.libraryId, id, 1_000)
+  const sweep = memory.expireShortTerm()
+  assert.equal(sweep.expired.some((row) => row.id === id), false, 'a promoted entry is no longer on a clock')
+
+  await assert.rejects(
+    () => memory.privateUpdate({ exec, id, layer: 'must_remember' }),
+    /pin_reason/,
+  )
+})
+
+test('the idle pass is told which drafts are about to expire', async () => {
+  const cwd = path.join(home, 'proj-brief')
+  const sessionId = 'short-brief'
+  const binding = state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+
+  const { id } = await memory.privateRemember({
+    exec,
+    content: 'We were still deciding whether to ship on Monday.',
+    title: 'ship date undecided',
+    layer: 'short_term',
+  })
+  const brief = privateMod.shortTermBrief(state.getSessionBinding(sessionId))
+  assert.ok(brief.includes('[short_term · 快到期了]'))
+  assert.ok(brief.includes(id))
+  assert.ok(brief.includes('memu_private_update'))
+  const prompt = privateMod.buildPrivateConsolidationPrompt(sessionId)
+  assert.ok(prompt.includes(id), 'the consolidation prompt must carry the decision list')
+})
+
+test('with shortTermTtlHours=0 the layer is closed instead of silently permanent', async () => {
+  const cwd = path.join(home, 'proj-off')
+  const sessionId = 'short-off'
+  state.ensureSession(sessionId, { cwd, agentPreset: 'coding' })
+  const exec = execFor(sessionId, cwd)
+  state.updateSettings({ shortTermTtlHours: 0 })
+  try {
+    await assert.rejects(
+      () => memory.privateRemember({ exec, content: 'Temporary note.', layer: 'short_term' }),
+      /disabled/,
+    )
+  } finally {
+    state.updateSettings({ shortTermTtlHours: 72 })
+  }
+})

package/tests/sidebar-beat.test.mjs

@@ -0,0 +1,208 @@
+// The sidebar heartbeat used to compare an in-process counter. A write served by a
+// different module instance — the model calling memu_private_remember mid-turn, a
+// curator job, a second window — moved the index on disk but never the counter, so
+// the panel sat stale until someone pressed Refresh by hand. These cases drive the
+// real MemoryTab with a fake hook runtime and prove the panel now refetches when
+// only the on-disk stamp moved.
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+const registrations = []
+
+function makeElement(type, props, ...children) {
+  return { type, props: { ...(props || {}), children: children.length <= 1 ? children[0] : children } }
+}
+
+let hooks = []
+let cursor = 0
+let effects = []
+
+const React = {
+  createElement: makeElement,
+  Fragment: Symbol('Fragment'),
+  useState(initial) {
+    const index = cursor++
+    if (hooks[index] === undefined) hooks[index] = typeof initial === "function" ? initial() : initial
+    return [hooks[index], (next) => { hooks[index] = typeof next === "function" ? next(hooks[index]) : next }]
+  },
+  useCallback: (fn) => fn,
+  useMemo: (fn) => fn(),
+  useEffect(fn, deps) { effects.push({ fn, deps }) },
+  useLayoutEffect() {},
+  useRef: (value) => ({ current: value }),
+  useSyncExternalStore: (_subscribe, getSnapshot) => getSnapshot(),
+}
+
+// setInterval is the heartbeat itself: the test keeps the callback and fires it by hand,
+// so no fake clock and no real 2.5s wait.
+const intervals = []
+globalThis.setInterval = (fn, ms) => { intervals.push({ fn, ms }); return intervals.length }
+globalThis.clearInterval = () => {}
+
+const visibilityListeners = new Set()
+globalThis.document = {
+  visibilityState: 'visible',
+  addEventListener(name, fn) { if (name === "visibilitychange") visibilityListeners.add(fn) },
+  removeEventListener(name, fn) { if (name === "visibilitychange") visibilityListeners.delete(fn) },
+  createElement: () => ({ style: {}, setAttribute() {}, appendChild() {}, remove() {}, click() {} }),
+  querySelector: () => null,
+  head: { appendChild() {} },
+  body: { appendChild() {} },
+}
+
+globalThis.window = {
+  __ModuleLoader__: {
+    load({ factory }) {
+      globalThis.__dshMemuExports = factory((name) => {
+        if (name === "react") return React
+        throw new Error("unexpected require: " + name)
+      })
+    },
+  },
+  addEventListener() {},
+  removeEventListener() {},
+}
+
+await import('../lib/client.js')
+const SNAPSHOT = {
+  binding: { sessionId: 'beat-session', libraryId: 'lib-1', useLibrary: true, useGlobal: true, scopeKey: 'demo' },
+  domain: 'coding',
+  folder: { scopeKey: 'demo', useLibrary: true, useGlobal: true },
+  effective: { useLibrary: true, useGlobal: true, enabled: true, folder: { scopeKey: 'demo', useLibrary: true, useGlobal: true } },
+  private: { items: [], active: 0, pinned: 0, total: 0 },
+  global: { items: [], active: 0, total: 0 },
+  domains: ['rp', 'coding'],
+}
+
+// The mock server answers the beat and the full read separately, and the test can
+// move the stamp without touching the counter — exactly the out-of-process write
+// the old heartbeat was blind to.
+function makeCtx() {
+  const calls = []
+  const server = { revision: 1, stamp: 'state:10:1|index-a' }
+  const call = async (_path, endpoint, payload) => {
+    calls.push({ endpoint, payload })
+    if (endpoint === 'getSidebarState') {
+      if (payload?.revisionOnly === true) return { ok: true, value: { revision: server.revision, stamp: server.stamp } }
+      return { ok: true, value: { ...SNAPSHOT, revision: server.revision, stamp: server.stamp } }
+    }
+    return { ok: true, value: {} }
+  }
+  const ctx = {
+    effect: (fn) => { try { fn() } catch {} },
+    locale: { register: () => () => {}, bind: () => (key) => key, get: () => 'zh' },
+    connection: { rpc: { call } },
+    sessions: { list: { subscribe: () => () => {}, getSnapshot: () => ({ byId: {}, ids: [] }) } },
+    get: (name) => (name === 'uiSession'
+      ? { adapter: { current: { getSnapshot: () => ({ key: 'beat-session' }), subscribe: () => () => {} } } }
+      : (name === 'sidebarRight' ? undefined : undefined)),
+    slots: { inject: (_name, callback) => callback({}), register: (spec, component) => { registrations.push({ spec, component }); return () => {} } },
+    // The plugin registers the tab inside inject(): the scope has to run effects now,
+    // or the registration never happens and there is nothing to mount.
+    inject: (_deps, callback) => callback({
+      effect: (fn) => { try { fn() } catch {} },
+      sidebarRightTabs: { register: () => () => {} },
+      get: () => undefined,
+    }),
+  }
+  return { ctx, calls, server }
+}
+
+const fullCalls = (calls) => calls.filter((c) => c.endpoint === 'getSidebarState' && c.payload?.revisionOnly !== true)
+const beatCalls = (calls) => calls.filter((c) => c.payload?.revisionOnly === true)
+
+async function mountTab() {
+  const harness = makeCtx()
+  globalThis.__dshMemuExports.apply(harness.ctx)
+  // A later paint must not reuse an earlier mount's registration: its ctx owns a
+  // different call log, and the assertions would silently read the wrong one.
+  const registration = registrations.filter((r) => r.spec?.name === 'sidebar.right.pane.tab').at(-1)
+  assert.ok(registration?.component, 'the memory tab was not registered into the sidebar slot')
+  return { component: registration.component, ...harness }
+}
+
+function expand(node, depth = 0) {
+  if (!node || typeof node !== 'object' || depth > 200) return
+  if (Array.isArray(node)) { for (const child of node) expand(child, depth + 1); return }
+  if (typeof node.type === 'function') { expand(node.type(node.props), depth + 1); return }
+  expand(node.props?.children, depth + 1)
+}
+
+const tick = async (times = 3) => {
+  for (let i = 0; i < times; i++) await new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+// Mount, run every effect the tab registered (mount fetch, write listener,
+// heartbeat, visibility listener), and let the first fetch settle.
+async function paintTab() {
+  hooks = []
+  cursor = 0
+  effects = []
+  intervals.length = 0
+  visibilityListeners.clear()
+  registrations.length = 0
+  const tab = await mountTab()
+  // The registered body is one wrapper element around MemoryTab; function components
+  // are not executed by createElement, so the tree has to be walked for the hooks and
+  // effects to exist at all.
+  expand(tab.component({ ctx: tab.ctx, t: (key) => key, sessionId: 'beat-session' }))
+  const started = effects.slice()
+  for (const effect of started) effect.fn()
+  await tick()
+  return { ...tab, started }
+}
+
+test('mounting paints once and arms exactly one heartbeat', async () => {
+  const tab = await paintTab()
+  assert.equal(fullCalls(tab.calls).length, 1, 'the panel fetches the first screen once on mount')
+  assert.equal(intervals.length, 1, 'exactly one heartbeat interval is armed')
+  assert.ok(intervals[0].ms > 0 && intervals[0].ms <= 5000, 'the beat is seconds apart, not minutes')
+  assert.equal(visibilityListeners.size, 1, 'returning to the window is listened for')
+})
+
+test('an unchanged marker does not refetch', async () => {
+  const tab = await paintTab()
+  await intervals[0].fn()
+  await tick()
+  assert.equal(beatCalls(tab.calls).length, 1, 'one cheap beat was sent')
+  assert.equal(fullCalls(tab.calls).length, 1, 'nothing moved, so nothing was refetched')
+})
+
+// The regression this file exists for: another process saved the index. The counter
+// this process holds does not move, only the on-disk stamp does.
+test('a stamp-only change refetches, even when the counter stands still', async () => {
+  const tab = await paintTab()
+  tab.server.stamp = 'state:10:1|index-a:bumped'
+  await intervals[0].fn()
+  await tick()
+  assert.equal(tab.server.revision, 1, 'the in-process counter deliberately did not move')
+  assert.equal(fullCalls(tab.calls).length, 2, 'the panel must refetch on the stamp alone')
+  const last = fullCalls(tab.calls).at(-1)
+  assert.equal(last.payload.revisionOnly, undefined, 'the refetch is the full first screen')
+})
+
+test('a counter move still refetches, and the beat carries no entries', async () => {
+  const tab = await paintTab()
+  tab.server.revision = 2
+  await intervals[0].fn()
+  await tick()
+  assert.equal(fullCalls(tab.calls).length, 2, 'a new revision must still refetch')
+  const beat = beatCalls(tab.calls).at(-1)
+  assert.deepEqual(Object.keys(beat.payload).sort(), ['revisionOnly'], 'the beat stays a bare marker')
+})
+
+test('becoming visible refetches once, and a hidden panel does not', async () => {
+  const tab = await paintTab()
+  for (const listener of visibilityListeners) listener()
+  await tick()
+  assert.equal(fullCalls(tab.calls).length, 2, 'returning to the window refetches')
+
+  globalThis.document.visibilityState = 'hidden'
+  await intervals[0].fn()
+  await tick()
+  assert.equal(beatCalls(tab.calls).length, 0, 'a hidden panel sends no beats at all')
+  for (const listener of visibilityListeners) listener()
+  await tick()
+  assert.equal(fullCalls(tab.calls).length, 2, 'a hidden panel does not refetch on the event either')
+  globalThis.document.visibilityState = 'visible'
+})