@@ -0,0 +1,12 @@
+---
+'@object-ui/app-shell': patch
+---
+
+fix(app-shell): a record's 动态 stream is read again after a save, so its count and rows hold the change without a reload
+
+Clause-②: no
+Metadata-protocol: none
+
+- **The record feed follows the record's invalidation.** A save through the edit dialog (or an action, an undo, a ⟳) put the record on the data-invalidation bus, and the page read the record again, but the 动态 feed kept the rows and the count the page payload answered when it opened. The feed now reads again on the same change, on the record page and in the drawer.
+- **The re-read asks what the open asked.** Once the record changed after the open, the feed asks the record page route for the streams the open asked, and only those (the discussion, the activity rows, the stream's count), so the new activity row and the server's count land in place. The activity row a save writes exists before the save answers, so one ask after the save sees it; nothing polls.
+- **The field changes follow the same change**, so on an object with `enable.trackHistory` the stream's field-change entries are read again too.
@@ -42,7 +42,7 @@ vi.mock('sonner', () => ({
   }),
 }));
 
-import { MetadataCtx } from '@object-ui/react';
+import { MetadataCtx, useMutationInvalidationBridge } from '@object-ui/react';
 import { RelatedCountStore } from '@object-ui/components';
 import { ObjectStackAdapter } from '@object-ui/data-objectstack';
 import { __clearRecordEditableCache } from '../../../plugin-detail/src/useRecordEditable';
@@ -128,6 +128,7 @@ function pageAnswer(id: string, body: any, answers: Answers) {
 }
 
 function answerFor(h: Held, answers: Answers): unknown {
+  if (h.method === 'PATCH') return { success: true, data: { object: OBJECT, id: 'c1', record: { id: 'c1', name: 'Contact c1', account: 'a1', ...h.body } } };
   const meta = /\/api\/v1\/meta\/object\/([^/?]+)/.exec(h.path);
   if (meta) return { success: true, data: ALL.find((o) => o.name === meta[1]) ?? null };
   const page = /\/api\/v1\/data\/[^/?]+\/([^/?]+)\/page$/.exec(h.path);
@@ -184,7 +185,14 @@ beforeEach(() => {
 });
 afterEach(() => { cleanup(); vi.unstubAllGlobals(); });
 
-async function boot(answers: Answers = {}, entry = `/apps/demo/${OBJECT}/record/c1`, objects: readonly unknown[] = ALL) {
+// The console's bridge from a dataSource write to the invalidation bus
+// (`AppContent` mounts it once): the edit dialog's save reaches the page by it.
+function Bridge({ dataSource }: { dataSource: unknown }) {
+  useMutationInvalidationBridge(dataSource);
+  return null;
+}
+
+async function boot(answers: Answers = {}, entry = `/apps/demo/${OBJECT}/record/c1`, objects: readonly unknown[] = ALL, embedded = false) {
   const { fetch, held } = heldTransport(answers);
   vi.stubGlobal('fetch', fetch);
   const ds = new ObjectStackAdapter({ baseUrl: BASE, fetch, autoReconnect: false });
@@ -198,7 +206,8 @@ async function boot(answers: Answers = {}, entry = `/apps/demo/${OBJECT}/record/
     <React.StrictMode>
       <MemoryRouter initialEntries={[entry]}>
         <MetadataCtx.Provider value={metadata}>
-          <RecordDetailView dataSource={ds as never} objects={objects as never} onEdit={() => {}} objectNameOverride={OBJECT} recordIdOverride="c1" />
+          <Bridge dataSource={ds} />
+          <RecordDetailView dataSource={ds as never} objects={objects as never} onEdit={() => {}} objectNameOverride={OBJECT} recordIdOverride="c1" embedded={embedded} />
         </MetadataCtx.Provider>
       </MemoryRouter>
     </React.StrictMode>,
@@ -299,3 +308,61 @@ describe('objectstack#29878 — the timeline ask counts the field changes of a t
     expect(page.body.timeline).toEqual({ discussion: true, activity: true, fieldChanges: false });
   });
 });
+
+/**
+ * objectstack#30035 — a save through the edit dialog (the adapter's `update`,
+ * whose MutationEvent the console's bridge puts on the invalidation bus) reads
+ * the 动态 stream again: its count and its rows hold the activity row the save
+ * wrote, with no reload, on the record page and in the drawer. The server
+ * writes that row inside the update (plugin-audit's `afterUpdate` writer, which
+ * the engine awaits before it answers), so the answer to one ask after the
+ * save holds it; nothing polls.
+ */
+describe('objectstack#30035 — the 动态 stream is read again after a save', () => {
+  const UPDATED = { ...ACTIVITY, id: 'ac2', type: 'updated', summary: 'changed the amount', timestamp: '2026-10-03T10:00:00.000Z' };
+
+  async function saveAndRead(embedded: boolean) {
+    const answers: Answers = { activity: { total: 1, records: [ACTIVITY] }, timeline: { total: 2 } };
+    const { held, open, ds } = await boot(answers, undefined, ALL, embedded);
+    const view = open();
+    await settle(held);
+    expect(chipOf(view.container)).toBe('2');
+    expect(view.container.textContent).not.toContain('changed the amount');
+    const before = held.length;
+
+    // The server's state after the save: the update wrote its activity row.
+    answers.activity = { total: 2, records: [UPDATED, ACTIVITY] };
+    answers.timeline = { total: 3 };
+    await act(async () => { void ds.update(OBJECT, 'c1', { name: 'Renamed' }); });
+    await settle(held);
+    return { view, after: held.slice(before) };
+  }
+
+  for (const [surface, embedded] of [['the record page', false], ['the drawer', true]] as const) {
+    it(`${surface}: the count and the rows hold the save's activity row without a reload`, async () => {
+      const { view, after } = await saveAndRead(embedded);
+      expect(chipOf(view.container)).toBe('3');
+      expect(view.container.textContent).toContain('changed the amount');
+      // One ask of the streams the open asked, and only those: no related
+      // list, verdict, projection or approval rides it.
+      const rereads = after.filter(isPage);
+      expect(rereads).toHaveLength(1);
+      expect(rereads[0].body).toEqual({
+        related: [],
+        discussion: true,
+        activity: { top: 5 },
+        timeline: { discussion: true, activity: true, fieldChanges: false },
+      });
+    });
+  }
+
+  it('a change to another record of the object reads nothing again', async () => {
+    const { held, open, ds } = await boot({ activity: { total: 1, records: [ACTIVITY] }, timeline: { total: 2 } });
+    open();
+    await settle(held);
+    const before = held.length;
+    await act(async () => { void ds.update(OBJECT, 'c2', { name: 'Other' }); });
+    await settle(held);
+    expect(held.slice(before).filter(isPage)).toEqual([]);
+  });
+});
@@ -45,8 +45,10 @@ import {
   recordPageComments,
   recordPageRelatedLists,
   recordPageRequestOf,
+  recordPageStreamsRequestOf,
   recordPageTimeline,
   seedRecordPageReaders,
+  type RecordPageStreamsAsk,
 } from './recordPagePayload.js';
 import { withPageTabsUrlSync } from '../utils/pageTabsUrlSync.js';
 import { RECORD_DETAIL_TAB_PARAM, RECORD_DRAWER_PARAM, RECORD_RELATED_ENLARGE_PARAM, RECORD_RELATED_ENLARGE_PUSHED_STATE as RELATED_ENLARGE_PUSHED, RECORD_TRAIL_PARAM, decodeRecordTrail, buildRecordTrailHref } from '../urlParams.js';
@@ -1220,7 +1222,16 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
      */
     activityRows: number;
     timeline: boolean;
+    /**
+     * objectstack#30035 — the stream parts the open asked, as asked: the
+     * feed's re-read after a change to this record asks these again.
+     */
+    streams: RecordPageStreamsAsk;
   } | null>(null);
+  // objectstack#30035 — the feed's re-read of the streams the open asked, once
+  // this record changed after the open: one ask per record and invalidation
+  // count, joined by every later run of the feed effect at that count.
+  const feedStreamsReread = useRef<{ feedKey: string; generation: number; payload: Promise<RecordPagePayload | null> } | null>(null);
   // objectstack#26589 — the record this viewer just decided an approval on,
   // as `objectName` + `recordId`. A pending approver with no standing access
   // reads the record only while their step waits (objectstack#26180): the
@@ -2469,6 +2480,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
       activity: plan.activity !== undefined,
       activityRows: plan.activity ?? 0,
       timeline: plan.timeline !== undefined,
+      streams: { discussion: plan.discussion, activity: plan.activity, timeline: plan.timeline },
     };
     seedRecordPageReaders({ payload, objectName, recordId: pureRecordId, principal: recordPagePrincipal, ...plan });
   }, [recordPagePlan, objectName, pureRecordId, dataSource, recordPagePrincipal]);
@@ -2884,8 +2896,10 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     // `t` is identity-stable per language; `language` refires the effect on a
     // language switch so the translated values re-localize, and
     // `displayLocale` on a display-locale switch so the dates do.
+    // `recordInvalidationNonce` (objectstack#30035): a change to this record
+    // reads its field changes again, the 动态 stream's other source.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [dataSource, pureRecordId, objectDef, historyEnabled, historyWanted, objects, language, displayLocale, tenantCurrency]);
+  }, [dataSource, pureRecordId, objectDef, historyEnabled, historyWanted, objects, language, displayLocale, tenantCurrency, recordInvalidationNonce]);
 
   // Fetch a directory of active users once per dataSource mount and expose
   // them as @-mention suggestions to the DiscussionContext. Capped at 50 to
@@ -3084,7 +3098,31 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     const retrying = feedRetryRef.current.get(threadId) ?? null;
     if (retrying) feedRetryRef.current.delete(threadId);
     const opened = recordPageRead.current;
-    const fromPage = !retrying && opened && opened.feedKey === threadId ? opened : null;
+    const openedHere = !retrying && opened && opened.feedKey === threadId ? opened : null;
+    // objectstack#30035 — a change to THIS record since the open (a save
+    // through the edit dialog, an action, an undo: `recordInvalidationNonce`
+    // re-runs this effect) leaves the open's payload stale, and the rows the
+    // change wrote are not in it. The streams the open asked are asked again,
+    // as asked, so the new rows AND the stream's count both come back from the
+    // server, read the way the open read them. The activity row a save writes
+    // exists before the save answers (the audit writer runs in the update's
+    // awaited `afterUpdate` hook), so this one ask after the change sees it:
+    // nothing polls. Every run at one invalidation count joins one ask.
+    const generation = recordPageGenerationRef.current;
+    let fromPage = openedHere;
+    if (openedHere && openedHere.generation !== generation) {
+      if (typeof dataSource.getRecordPage === 'function') {
+        const held = feedStreamsReread.current;
+        const payload = held && held.feedKey === threadId && held.generation === generation
+          ? held.payload
+          : dataSource.getRecordPage(objectName, pureRecordId, recordPageStreamsRequestOf(openedHere.streams));
+        feedStreamsReread.current = { feedKey: threadId, generation, payload };
+        fromPage = { ...openedHere, payload };
+      } else {
+        fromPage = null;
+      }
+    }
+    const rereading = fromPage !== null && fromPage !== openedHere;
     // The two reads below run in PARALLEL and are collected here so the
     // loading flag can close over BOTH of them — see the `allSettled` at the
     // end of this effect.
@@ -3289,11 +3327,18 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
         recordVerdict('activity', 'answered');
         // objectstack#28737 — the payload asked only the 动态 panel's rows and
         // the record holds more: the 动态 tab reads the window when it opens.
-        const peek = !!fromPage?.activity
+        const answeredPeek = !!fromPage?.activity
           && fromPage.activityRows < RECORD_PAGE_ACTIVITY_ROWS
           && typeof res?.total === 'number'
           && res.total > (res?.data?.length ?? 0);
-        setActivityPeekByRecord(prev => ((prev[threadId] ?? false) === peek ? prev : { ...prev, [threadId]: peek }));
+        setActivityPeekByRecord(prev => {
+          const held = prev[threadId] ?? false;
+          // objectstack#30035 — a re-read after a change merges the newest
+          // rows into what the feed already holds: a feed that holds the
+          // window (the 动态 tab read it) still does, so it never asks it again.
+          const peek = rereading ? held && answeredPeek : answeredPeek;
+          return held === peek ? prev : { ...prev, [threadId]: peek };
+        });
         if (!res?.data?.length) return;
         const mapped = activityRowsToFeedItems(res.data, t('detail.systemActor', { defaultValue: 'System' }));
         if (!mapped.length) return;
@@ -3321,7 +3366,10 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     });
 
     return () => { cancelled = true; };
-  }, [dataSource, objectName, pureRecordId, currentUser, feedsEnabled, activitiesEnabled, feedFetchKey, reactionStore, feedWanted, feedPlanReady, feedRetryNonce]);
+    // objectstack#30035 — `recordInvalidationNonce`: a change to this record
+    // reads its feed again (#2269, refresh data in place), as it reads the
+    // record again in the record-load effect above.
+  }, [dataSource, objectName, pureRecordId, currentUser, feedsEnabled, activitiesEnabled, feedFetchKey, reactionStore, feedWanted, feedPlanReady, feedRetryNonce, recordInvalidationNonce]);
 
   // objectstack#29188 — the load-failure notice's Retry: read this record's
   // FAILED feed reads again, and only those. The feed shows its loading state
 
@@ -238,6 +238,24 @@ export function recordPageRequestOf(plan: {
   };
 }
 
+/** The record's streams a page asked when it opened (objectstack#30035): the feed's parts of its plan. */
+export interface RecordPageStreamsAsk {
+  discussion?: boolean;
+  activity?: number;
+  timeline?: { discussion: boolean; activity: boolean; fieldChanges: boolean };
+}
+
+/**
+ * The request body for the feed's re-read after a change to the record
+ * (objectstack#30035): the streams the open asked, as asked, and no other
+ * part — no related list, verdict, projection or approval, which their own
+ * readers read again on the same change. The route answers the record with
+ * it, as its read gate.
+ */
+export function recordPageStreamsRequestOf(streams: RecordPageStreamsAsk): RecordPageRequest {
+  return recordPageRequestOf({ expand: [], related: [], explain: [], fieldAccess: false, approvals: false, ...streams });
+}
+
 /** A refused part, thrown as the read it replaces throws its refusal. */
 function refusal(error: RecordPagePartRefusal | undefined, fallback: string): Error {
   return Object.assign(new Error(error?.message ?? fallback), {