@@ -25,6 +25,13 @@ vi.mock('node:fs/promises', async () => {
   return { ...actual, stat: vi.fn(actual.stat) }
 })
 
+/** The catch-up refresh a live subscription schedules; later counts start after it. */
+async function flushCatchUpRefresh(refresh: ReturnType<typeof vi.fn>): Promise<void> {
+  await vi.advanceTimersByTimeAsync(300)
+  expect(refresh).toHaveBeenCalledOnce()
+  refresh.mockClear()
+}
+
 const originalPlatform = process.platform
 const subscribeMock = vi.mocked(subscribeViaWatcherProcess)
 let fixture: AliasedWatcherRoot
@@ -95,6 +102,7 @@ it.each(['zero', 'ctime'] as const)(
     const options = { enabled: true, devPaths: [fixture.realRoot], refresh, reapIdle: vi.fn() }
     housekeeping.sync(options)
     await Promise.resolve()
+    await flushCatchUpRefresh(refresh)
     for (let tick = 0; tick < 3; tick += 1) {
       await vi.advanceTimersByTimeAsync(60_000)
       await expect(checks.mock.results[tick]?.value).resolves.toBe(false)
@@ -192,17 +200,20 @@ it('recovers a silent replacement when previously unknown identity first becomes
   const options = { enabled: true, devPaths: [fixture.realRoot], refresh, reapIdle: vi.fn() }
   housekeeping.sync(options)
   await Promise.resolve()
+  await flushCatchUpRefresh(refresh)
   await rename(fixture.realRoot, join(fixture.base, 'old'))
   await mkdir(fixture.realRoot)
   await vi.advanceTimersByTimeAsync(60_000)
-  await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce())
-  expect(subscribeMock).toHaveBeenCalledTimes(2)
+  await vi.waitFor(() => expect(subscribeMock).toHaveBeenCalledTimes(2))
+  await vi.advanceTimersByTimeAsync(300)
+  // The rebind refresh, then the rebound subscription's one catch-up.
+  expect(refresh).toHaveBeenCalledTimes(2)
   expect(subscriptions[0]?.unsubscribe).toHaveBeenCalledOnce()
   for (let tick = 1; tick < 4; tick += 1) {
     await vi.advanceTimersByTimeAsync(60_000)
     await expect(checks.mock.results[tick]?.value).resolves.toBe(false)
   }
-  expect(refresh).toHaveBeenCalledOnce()
+  expect(refresh).toHaveBeenCalledTimes(2)
   expect(subscribeMock).toHaveBeenCalledTimes(2)
 })
 
@@ -219,10 +230,12 @@ it('retries a failed native setup for an unknown present root on the existing ma
   housekeeping.sync(options)
   await Promise.resolve()
   await vi.advanceTimersByTimeAsync(60_000)
-  await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce())
-  expect(subscribeMock).toHaveBeenCalledTimes(2)
+  await vi.waitFor(() => expect(subscribeMock).toHaveBeenCalledTimes(2))
+  await vi.advanceTimersByTimeAsync(300)
+  // The retry refresh, then the retried subscription's one catch-up.
+  expect(refresh).toHaveBeenCalledTimes(2)
   await vi.advanceTimersByTimeAsync(180_000)
-  expect(refresh).toHaveBeenCalledOnce()
+  expect(refresh).toHaveBeenCalledTimes(2)
   expect(subscribeMock).toHaveBeenCalledTimes(2)
 })
 
@@ -238,6 +251,7 @@ it('uses native notifications to recover when a silent replacement has no usable
   const options = { enabled: true, devPaths: [fixture.realRoot], refresh, reapIdle: vi.fn() }
   housekeeping.sync(options)
   await Promise.resolve()
+  await flushCatchUpRefresh(refresh)
   await rename(fixture.realRoot, join(fixture.base, 'old'))
   await mkdir(fixture.realRoot)
   await vi.advanceTimersByTimeAsync(60_000)
 
@@ -37,6 +37,14 @@ type PluginWatchSubscription = {
 }
 
 const devPath = resolve('plugins', 'demo')
+
+/** The catch-up refresh a live subscription schedules; later counts start after it. */
+async function flushCatchUpRefresh(refresh: ReturnType<typeof vi.fn>): Promise<void> {
+  await vi.advanceTimersByTimeAsync(300)
+  expect(refresh).toHaveBeenCalledOnce()
+  refresh.mockClear()
+}
+
 const originalPlatform = process.platform
 const subscribeMock = vi.mocked(subscribeViaWatcherProcess)
 let subscriptions: PluginWatchSubscription[] = []
@@ -230,6 +238,27 @@ describe('PluginDevWatcher', () => {
     expect(refresh).toHaveBeenCalledTimes(2)
   })
 
+  it('catches up once when a dev root goes live after an edit it could not report', async () => {
+    vi.useFakeTimers()
+    const pending: (() => void)[] = []
+    subscribeMock.mockImplementation((path, callback, options, hooks = {}) => {
+      const unsubscribe = vi.fn().mockResolvedValue(undefined)
+      subscriptions.push({ path, callback, options, hooks, unsubscribe })
+      return new Promise((resolve) => pending.push(() => resolve({ unsubscribe })))
+    })
+    const { refresh } = startDevWatcher(vi.fn(), vi.fn(), [devPath])
+    // The edit lands while the native subscription is still being set up, so no event reports it.
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(refresh).not.toHaveBeenCalled()
+    for (const goLive of pending) {
+      goLive()
+    }
+    await vi.advanceTimersByTimeAsync(300)
+    expect(refresh).toHaveBeenCalledOnce()
+    await vi.advanceTimersByTimeAsync(60_000)
+    expect(refresh).toHaveBeenCalledOnce()
+  })
+
   it('refreshes the whole plugin projection after an overflow', () => {
     vi.useFakeTimers()
     const { refresh, onWatcherError } = startDevWatcher()
@@ -504,6 +533,7 @@ describe('PluginDevWatcher', () => {
       const options = { enabled: true, devPaths: [path], refresh, reapIdle: vi.fn() }
       lifecycle.sync(options)
       await Promise.resolve()
+      await flushCatchUpRefresh(refresh)
       for (let tick = 0; tick < 3; tick += 1) {
         await vi.advanceTimersByTimeAsync(60_000)
         expect(checkBindings).toHaveBeenCalledTimes(tick + 1)
@@ -567,6 +597,7 @@ describe('PluginDevWatcher', () => {
     const options = { enabled: true, devPaths: [path], refresh, reapIdle: vi.fn() }
     lifecycle.sync(options)
     await Promise.resolve()
+    await flushCatchUpRefresh(refresh)
     const root = pluginRootSubscription()
 
     for (const type of ['create', 'delete'] as const) {
@@ -601,22 +632,26 @@ describe('PluginDevWatcher', () => {
     const options = { enabled: true, devPaths: [path], refresh, reapIdle: vi.fn() }
     lifecycle.sync(options)
     await Promise.resolve()
+    await flushCatchUpRefresh(refresh)
     const root = pluginRootSubscription()
     await rename(path, join(aliasedRoot.base, 'old'))
     await mkdir(path)
 
     await vi.advanceTimersByTimeAsync(60_000)
-    await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce())
+    await vi.waitFor(() => expect(subscribeMock).toHaveBeenCalledTimes(2))
+    await vi.advanceTimersByTimeAsync(300)
+    // The rebind refresh, then the replacement root's one catch-up.
+    expect(refresh).toHaveBeenCalledTimes(2)
     expect(root.unsubscribe).toHaveBeenCalledOnce()
     expect(subscriptions.map((item) => ({ path: item.path, options: item.options }))).toEqual([
       { path, options: { backend: 'windows' } },
       { path, options: { backend: 'windows' } }
     ])
     subscriptions.at(-1)?.callback(null, [{ type: 'create', path: join(path, 'manifest.json') }])
     await vi.advanceTimersByTimeAsync(300)
-    expect(refresh).toHaveBeenCalledTimes(2)
+    expect(refresh).toHaveBeenCalledTimes(3)
     await vi.advanceTimersByTimeAsync(60_000)
-    expect(refresh).toHaveBeenCalledTimes(2)
+    expect(refresh).toHaveBeenCalledTimes(3)
     expect(subscribeMock).toHaveBeenCalledTimes(2)
     lifecycle.dispose()
     expect(vi.getTimerCount()).toBe(0)
 
@@ -209,6 +209,11 @@ export class PluginDevWatcher {
           return
         }
         this.subscriptions.push(created)
+        // Why: the watcher reports only what changes after it is live, and discovery ran before
+        // that, so an edit made in between (a save right after adding the folder) would be lost.
+        if (!parent) {
+          this.scheduleRefresh(refresh)
+        }
       })
       .catch(() => {
         if (isActive()) {