fix(mobile/search): revert drop-on-close — keep closed pads searchable

I had set tab.close to drop the pad's body from the content-search cache, on the theory that this stopped the "edited pad still matches old content" bug. But:

- The original stale-content bug was the WebView's HTTP cache returning the old /export/txt response. That's already fixed by `cache: 'no-store'` on the refresh fetch.
- Dropping on close threw away useful history. User just reported: open two pads (one with "Welcome" in the body), close both, search "welcome" — nothing comes up. Closed pads ARE a real switch target.

Reverted the close-side drop. The cache now retains last-known content for any pad we've ever opened in the session. Re-opening a pad immediately refreshes its cache via the open path; searching while a pad is open also refreshes via searchPadContent. So the only "stale" entries are pads the user closed and hasn't re-opened — those keep their last-known body for search, which is the intended behaviour.

Test rewritten to pin the new contract: open two pads, close both, search the welcome-only body — exactly the user's flow. Failed without this commit, passes with it.

Author: JohnMcLear

packages/mobile/src/platform/capacitor.ts

@@ -100,13 +100,15 @@ export function createCapacitorPlatform(): Platform {
       }),
       close: (input) =>
         wrap(async () => {
-          // Drop the closed pad from the content-search cache so search
-          // results only reflect currently-open pads. Without this, a
-          // closed pad's last-known body keeps surfacing in hits even
-          // though the user can't see it. We look up workspace+padName
-          // BEFORE close removes the tab from the store.
-          const tab = tabStore.listAll().find((t) => t.tabId === input.tabId);
-          if (tab) padContentIndex.dropEntry(tab.workspaceId, tab.padName);
+          // We keep the closed pad's body in the content-search cache.
+          // Closed pads stay searchable using their last-known content
+          // so the user can find a pad they viewed earlier in the
+          // session via its body. On the next refresh (when re-opened
+          // or on a tab.open elsewhere), the cache entry will be
+          // overwritten with fresh content. The stale-content concern
+          // from the original report turned out to be the WebView's
+          // HTTP cache, addressed by `cache: 'no-store'` in
+          // pad-content-index.
           tabStore.close(input.tabId);
           return { ok: true } as const;
         }),

packages/mobile/src/platform/pad-content-index.ts

@@ -199,16 +199,6 @@ export function clear(workspaceId?: string): void {
   }
 }
 
-/**
- * Drop the cached body for a single (workspace, pad). Called on
- * tab.close so search results only reflect the content of CURRENTLY-
- * OPEN pads — leaving the cache around after close lets stale text
- * from a previously-viewed pad keep showing up in search hits.
- */
-export function dropEntry(workspaceId: string, padName: string): void {
-  cache.delete(keyFor(workspaceId, padName));
-}
-
 /** Test seam: lets tests poke entries in directly without going through
  *  fetch. The capacitor.ts boot path only calls index() / search() /
  *  clear() — this is wider but kept narrow by the `__` prefix. */

packages/mobile/tests/smoke.spec.ts

@@ -553,14 +553,18 @@ test('content search keeps working when the network goes down (uses cached body)
   await expect(results.filter({ hasText: 'welcome procedures' })).toHaveCount(1, { timeout: 5_000 });
 });
 
-test('closed pads disappear from content-search hits', async ({ page }) => {
-  // Regression: user noticed that searching "welcome" after editing a
-  // pad to "moo" still returned the pad. The cached body wasn't being
-  // cleared on close, so stale text from previously-viewed pads kept
-  // surfacing. We now drop the cache entry on tab.close so search
-  // only reflects currently-open pads.
-  await page.route('**/p/stale-pad/export/txt', async (route) => {
-    await route.fulfill({ status: 200, contentType: 'text/plain', body: 'Welcome to the stale pad' });
+test('closed pads stay searchable by their last-known content', async ({ page }) => {
+  // User flow: open two pads (one body contains "Welcome"), close them
+  // both, search "welcome" — expect the welcome-bodied pad to surface
+  // using its cached body. Pads-in-history are a real switch target,
+  // so the closed-pad path stays in the search index. (Stale-content
+  // concerns are addressed by `cache: 'no-store'` on the refresh fetch
+  // when the pad is currently open.)
+  await page.route('**/p/closed-welcome/export/txt', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'text/plain', body: 'Welcome aboard the closed pad' });
+  });
+  await page.route('**/p/closed-other/export/txt', async (route) => {
+    await route.fulfill({ status: 200, contentType: 'text/plain', body: 'Sprint planning notes here.' });
   });
 
   await page.addInitScript(seedWorkspace);
@@ -569,31 +573,33 @@ test('closed pads disappear from content-search hits', async ({ page }) => {
     page.getByRole('button', { name: /open instance acme/i }),
   ).toBeVisible({ timeout: 15_000 });
 
-  // Open, fetch content, then close.
-  await openPad(page, WS_ID, 'stale-pad');
-  await page.waitForResponse((r) => r.url().includes('/stale-pad/export/txt'));
-  await page.evaluate((id) => {
+  // Open both pads, wait for their bodies to be cached, then close both.
+  await openPad(page, WS_ID, 'closed-welcome');
+  await page.waitForResponse((r) => r.url().includes('/closed-welcome/export/txt'));
+  await openPad(page, WS_ID, 'closed-other');
+  await page.waitForResponse((r) => r.url().includes('/closed-other/export/txt'));
+
+  await page.evaluate(async (workspaceId) => {
     const platform = (window as unknown as { __test_platform: {
       tab: { close(input: { tabId: string }): Promise<unknown> };
     } }).__test_platform;
-    return platform.tab.close({ tabId: id });
-  }, `${WS_ID}::stale-pad`);
+    await platform.tab.close({ tabId: `${workspaceId}::closed-welcome` });
+    await platform.tab.close({ tabId: `${workspaceId}::closed-other` });
+  }, WS_ID);
 
-  // Open QuickSwitcher and search the cached word.
+  // Open QuickSwitcher and search "welcome". Only the welcome-bodied
+  // pad should match (via the content-search path — neither pad name
+  // contains "welcome").
   await page.evaluate(() => {
     window.dispatchEvent(new KeyboardEvent('keydown', { key: 'k', ctrlKey: true, bubbles: true }));
   });
   await expect(page.getByRole('dialog', { name: /quick switcher/i })).toBeVisible({ timeout: 5_000 });
   await page.getByRole('textbox', { name: /quick switcher search input/i }).fill('welcome');
 
-  // The pad was closed → its cache entry was dropped → no content-
-  // match snippet for "Welcome to the stale pad" should appear. (The
-  // pad name doesn't contain "welcome" either, so we don't get the
-  // name-match path.)
-  await page.waitForTimeout(300); // > the 200ms content-search debounce
   const results = page.getByRole('option');
-  await expect(results.filter({ hasText: 'Welcome to the stale pad' })).toHaveCount(0);
-  await expect(results.filter({ hasText: 'stale-pad' })).toHaveCount(0);
+  await expect(results.filter({ hasText: 'Welcome aboard' })).toHaveCount(1, { timeout: 5_000 });
+  // The unrelated closed pad's body doesn't have "welcome" → must not show.
+  await expect(results.filter({ hasText: 'Sprint planning' })).toHaveCount(0);
 });
 
 // X-Frame-Options DENY / SAMEORIGIN detection from pure JS is unreliable