@@ -0,0 +1,12 @@
+---
+'@object-ui/core': patch
+---
+
+fix(core): a successful `operation: 'update'` action now refreshes the record it wrote, with no `refreshAfter: true` (#29935)
+
+Clause-②: no
+Metadata-protocol: none
+
+The spec fills in `refreshAfter: false` on an action authored without it, and that parsed shape is what the Console is served. The server-action dispatch (`createServerActionHandler`) refreshed only when `refreshAfter !== false`, so a declared update never refreshed: the route wrote the record and answered 200, the toast reported success, and the record page kept the old values and the action button whose `visible` predicate had turned false. The list the record came from kept it under a filter it no longer matched.
+
+A declared `operation: 'update'` writes the record it addresses by definition, so its success is now treated as a record change whatever `refreshAfter` says, the same way a client-side `dataSource.update` already reaches every reader. The record-scoped invalidation re-reads the record page (drawer and full page) and refetches every list of that object. `refreshAfter` keeps governing every other server action: a non-update action served with the default `refreshAfter: false` still sends no re-read. The spec default is unchanged.
@@ -677,7 +677,7 @@ and [Connect an MCP Client](/docs/ai/connect-mcp).
 | Click → `Action 'x' … not found` | `target`-style script with no registered handler — add the `registerAction` call in `onEnable` (Path B above) |
 | REST → 400 naming the action's `type` | The type has no server dispatch (`url`/`modal`/`form`/`api`) — open its `target` in the client, or call that endpoint directly |
 | Appears in UI, missing from `list_actions` (MCP) | `ai.exposed` not `true`, `ai.description` under 40 characters, or the type isn't headless-callable |
-| Runs but the list looks stale | Add `refreshAfter: true` |
+| Runs but the list looks stale | Add `refreshAfter: true` (an `operation: 'update'` action re-reads its record and the object's lists on its own) |
 
 ## Related
 
 
@@ -0,0 +1,329 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectstack#29935 — after a successful declared `operation: 'update'` the
+ * record page shows what the route wrote, with no `refreshAfter: true`.
+ *
+ * The spec materializes `refreshAfter: false` on an action authored without
+ * it, and that parsed shape is what the Console is served. The runner hands an
+ * update action to the page's registered `script` dispatch, whose refresh read
+ * `refreshAfter !== false`: the route answered 200, the toast said "Ticket
+ * resolved.", and the page kept the old status and the Resolve button whose
+ * `visible` predicate was now false. A declared update's success is now a
+ * record change.
+ *
+ * Where it reaches: the record-scoped `notifyDataChanged` the page sends
+ * re-reads this record, and every list reader of the object
+ * (`useDataInvalidation(objectName)` with no record id — the hook `ListView`
+ * and `ObjectView` refetch on) refetches with its own filter, so the record
+ * leaves a list it no longer matches. The drawer is this same view mounted
+ * `embedded` beside its list.
+ *
+ * CONTROL: a non-update `script` action served with the same
+ * `refreshAfter: false` still sends no re-read.
+ *
+ * Harness: the `RecordDetailView.apiNewTabUrl-26747` mount — the real record
+ * page, header and runner, and the real console server-action handler, with
+ * only the authenticated fetch answered here.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor, fireEvent, cleanup, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+
+const authFetchSpy = vi.fn();
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({ user: null, activeOrganization: null }),
+  createAuthenticatedFetch: () => authFetchSpy,
+}));
+
+vi.mock('@object-ui/collaboration', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useRecordPresence: () => [],
+  PresenceAvatars: () => null,
+}));
+
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), {
+    success: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warning: vi.fn(),
+    loading: vi.fn(),
+    dismiss: vi.fn(),
+  }),
+}));
+
+vi.mock('./ActionParamDialog', () => ({ ActionParamDialog: () => null }));
+vi.mock('./ActionResultDialog', () => ({ ActionResultDialog: () => null }));
+vi.mock('./FlowRunner', () => ({ FlowRunner: () => null }));
+vi.mock('./MetadataInspector', () => ({
+  MetadataPanel: () => null,
+  useMetadataInspector: () => ({ showDebug: false, toggle: () => {} }),
+}));
+
+import { toast } from 'sonner';
+import { I18nProvider } from '@object-ui/i18n';
+import { MetadataCtx, useDataInvalidation } from '@object-ui/react';
+import { RecordDetailView } from './RecordDetailView';
+import { FavoritesProvider } from '../context/FavoritesProvider';
+
+const OBJECT_NAME = 'support_desk_ticket';
+const RECORD_ID = 'tkt_1';
+const OTHER_ID = 'tkt_2';
+const RECORD_PATH = `/apps/support_desk/${OBJECT_NAME}/record/${RECORD_ID}`;
+const ACTION_URL = `/api/v1/actions/${OBJECT_NAME}/resolve_ticket`;
+
+const FIELDS = {
+  id: { type: 'text', label: 'Id' },
+  subject: { type: 'text', label: 'Subject' },
+  status: {
+    type: 'select',
+    label: 'Status',
+    options: [
+      { value: 'open', label: 'Open' },
+      { value: 'resolved', label: 'Resolved' },
+      { value: 'closed', label: 'Closed' },
+    ],
+  },
+};
+
+/**
+ * The tutorial's action as the Console is served it: parsed, so
+ * `type: 'script'` and `refreshAfter: false` are materialized although the
+ * author wrote neither.
+ */
+const resolveTicket = {
+  name: 'resolve_ticket',
+  label: 'Resolve',
+  objectName: OBJECT_NAME,
+  type: 'script',
+  operation: 'update',
+  patch: { status: 'resolved' },
+  locations: ['record_header'],
+  visible: 'record.status != "resolved" && record.status != "closed"',
+  successMessage: 'Ticket resolved.',
+  refreshAfter: false,
+};
+
+/** CONTROL: a server-side script action that writes nothing the page reads. */
+const notifyOwner = {
+  name: 'notify_owner',
+  label: 'Notify owner',
+  objectName: OBJECT_NAME,
+  type: 'script',
+  locations: ['record_header'],
+  successMessage: 'Owner notified.',
+  refreshAfter: false,
+};
+
+/** The stored rows; the action route writes here, the reads read here. */
+let rows: Array<Record<string, unknown>>;
+
+function makeDataSource() {
+  return {
+    find: vi.fn(async (_object: string, query?: { $filter?: Record<string, unknown> }) => {
+      const status = query?.$filter?.status;
+      const data = rows.filter((r) => status === undefined || r.status === status).map((r) => ({ ...r }));
+      return { data, total: data.length };
+    }),
+    findOne: vi.fn(async (_object: string, id: string) => ({ ...rows.find((r) => r.id === id)! })),
+    create: vi.fn(async () => ({})),
+    update: vi.fn(async () => ({})),
+    delete: vi.fn(async () => ({})),
+  } as any;
+}
+
+/**
+ * A list reader of the object — the `useDataInvalidation(objectName)` a list
+ * view refetches on — drawing the Open list.
+ */
+function OpenTicketsProbe({ dataSource }: { dataSource: any }) {
+  const nonce = useDataInvalidation(OBJECT_NAME);
+  const [ids, setIds] = React.useState<string[] | null>(null);
+  React.useEffect(() => {
+    let live = true;
+    void dataSource.find(OBJECT_NAME, { $filter: { status: 'open' } }).then((res: { data: Array<{ id: string }> }) => {
+      if (live) setIds(res.data.map((r) => r.id));
+    });
+    return () => { live = false; };
+  }, [dataSource, nonce]);
+  return <ul data-testid="open-list">{(ids ?? []).map((id) => <li key={id}>{id}</li>)}</ul>;
+}
+
+async function mount(actions: unknown[], mode: 'page' | 'drawer') {
+  const objects = [
+    { name: OBJECT_NAME, label: 'Ticket', managedBy: 'platform', fields: FIELDS, actions },
+  ];
+  const metadata = {
+    objects,
+    pages: [],
+    loading: false,
+    error: null,
+    refresh: async () => {},
+    invalidate: () => {},
+    ensureType: async () => [],
+    getItem: async () => null,
+    getItemsByType: () => [],
+  } as any;
+  const dataSource = makeDataSource();
+  const view = mode === 'page'
+    ? (
+      <Routes>
+        <Route
+          path="/apps/:appName/:objectName/record/:recordId"
+          element={<RecordDetailView dataSource={dataSource} objects={objects} onEdit={() => {}} />}
+        />
+      </Routes>
+    )
+    : (
+      <>
+        <OpenTicketsProbe dataSource={dataSource} />
+        <RecordDetailView
+          dataSource={dataSource}
+          objects={objects}
+          onEdit={() => {}}
+          objectNameOverride={OBJECT_NAME}
+          recordIdOverride={RECORD_ID}
+          embedded
+        />
+      </>
+    );
+  render(
+    <I18nProvider config={{ defaultLanguage: 'en', detectBrowserLanguage: false }} persistLanguage={false}>
+      <MetadataCtx.Provider value={metadata}>
+        <FavoritesProvider>
+          <MemoryRouter initialEntries={[RECORD_PATH]}>{view}</MemoryRouter>
+        </FavoritesProvider>
+      </MetadataCtx.Provider>
+    </I18nProvider>,
+  );
+  await waitFor(() => expect(dataSource.findOne).toHaveBeenCalled());
+  await waitFor(() => expect(document.querySelector('[role="toolbar"]')).toBeTruthy());
+  return dataSource;
+}
+
+/** Every inline CTA the header currently renders, by visible label. */
+function headerCtaLabels(): string[] {
+  const bar = document.querySelector('[role="toolbar"]');
+  if (!bar) return [];
+  return Array.from(bar.querySelectorAll('button'))
+    .map((b) => (b.textContent ?? '').trim())
+    .filter(Boolean);
+}
+
+/**
+ * The header path bar's current stage, as each rendering of it (wide and
+ * narrow) names it to assistive tech.
+ */
+function currentStages(): string[] {
+  return Array.from(document.querySelectorAll('[role="listitem"][aria-current="step"]'))
+    .map((el) => el.getAttribute('aria-label') ?? '');
+}
+
+function actionPosts(): string[] {
+  return authFetchSpy.mock.calls
+    .map((c) => String(c[0]))
+    .filter((u) => u.includes('/api/v1/actions/'));
+}
+
+async function click(label: string) {
+  await act(async () => {
+    fireEvent.click(screen.getByRole('button', { name: label }));
+  });
+}
+
+beforeEach(() => {
+  cleanup();
+  localStorage.clear();
+  rows = [
+    { id: RECORD_ID, subject: 'Printer jam', status: 'open' },
+    { id: OTHER_ID, subject: 'VPN down', status: 'open' },
+  ];
+  authFetchSpy.mockReset();
+  authFetchSpy.mockImplementation(async (url: string, init?: RequestInit) => {
+    // The action route: write the declared patch AS the route does, answer
+    // the declarative update's envelope with the written record.
+    if (String(url).endsWith(ACTION_URL) && init?.method === 'POST') {
+      const row = rows.find((r) => r.id === RECORD_ID)!;
+      row.status = 'resolved';
+      return new Response(
+        JSON.stringify({ success: true, data: { ok: true, action: 'resolve_ticket', objectName: OBJECT_NAME, recordId: RECORD_ID, result: { ...row } } }),
+        { status: 200, headers: { 'content-type': 'application/json' } },
+      );
+    }
+    return new Response(JSON.stringify({ success: true, data: {} }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    });
+  });
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async () =>
+      new Response(JSON.stringify({ data: [] }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    ),
+  );
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe('objectstack#29935 — a declared update action reflects its write on the record page', () => {
+  it('full page: after the 200 the page re-reads, the path bar reads Resolved and the Resolve button is gone', async () => {
+    const dataSource = await mount([resolveTicket], 'page');
+    expect(headerCtaLabels()).toContain('Resolve');
+    await waitFor(() => expect(currentStages()).toContain('Open, current stage'));
+    const readsBefore = dataSource.findOne.mock.calls.length;
+
+    await click('Resolve');
+
+    expect(actionPosts()).toEqual([expect.stringContaining(ACTION_URL)]);
+    await waitFor(() => expect(toast.success).toHaveBeenCalledWith('Ticket resolved.', expect.anything()));
+    await waitFor(() => expect(dataSource.findOne.mock.calls.length).toBeGreaterThan(readsBefore));
+    await waitFor(() => expect(headerCtaLabels()).not.toContain('Resolve'));
+    await waitFor(() => expect(currentStages()).toContain('Resolved, current stage'));
+    expect(currentStages()).not.toContain('Open, current stage');
+  });
+
+  it('drawer: the same click re-reads the record and the Open list it came from drops it', async () => {
+    const dataSource = await mount([resolveTicket], 'drawer');
+    const openList = () => Array.from(screen.getByTestId('open-list').querySelectorAll('li')).map((li) => li.textContent);
+    await waitFor(() => expect(openList()).toEqual([RECORD_ID, OTHER_ID]));
+    await waitFor(() => expect(currentStages()).toContain('Open, current stage'));
+    const readsBefore = dataSource.findOne.mock.calls.length;
+
+    await click('Resolve');
+
+    await waitFor(() => expect(dataSource.findOne.mock.calls.length).toBeGreaterThan(readsBefore));
+    await waitFor(() => expect(headerCtaLabels()).not.toContain('Resolve'));
+    await waitFor(() => expect(currentStages()).toContain('Resolved, current stage'));
+    await waitFor(() => expect(openList()).toEqual([OTHER_ID]));
+  });
+
+  it('CONTROL: a non-update script action served with `refreshAfter: false` sends no re-read', async () => {
+    const dataSource = await mount([notifyOwner], 'page');
+    const readsBefore = dataSource.findOne.mock.calls.length;
+
+    await click('Notify owner');
+
+    await waitFor(() => expect(toast.success).toHaveBeenCalledWith('Owner notified.', expect.anything()));
+    expect(actionPosts()).toEqual([expect.stringContaining(`/api/v1/actions/${OBJECT_NAME}/notify_owner`)]);
+    // Let any refetch the click could have scheduled land before counting.
+    await act(async () => { await new Promise((r) => setTimeout(r, 50)); });
+    expect(dataSource.findOne.mock.calls.length).toBe(readsBefore);
+  });
+});
@@ -96,7 +96,7 @@ const script = createServerActionHandler({
   fetch: myAuthenticatedFetch,          // your auth wrapper (Bearer/cookies/...)
   baseUrl: 'https://api.example.com',   // '' or omitted = same-origin
   resolveObject: () => currentObject,   // fallback when the action has no objectName
-  onRefresh: () => refetchData(),       // called per the action's refreshAfter
+  onRefresh: () => refetchData(),       // called per refreshAfter, and after every operation: 'update'
 })
 
 // Registered handlers beat the built-in executors:
 
@@ -340,6 +340,37 @@ describe('createServerActionHandler — refresh semantics', () => {
     expect(onRefresh).toHaveBeenCalledTimes(1);
     expect(res).toMatchObject({ success: true, reload: false });
   });
+
+  // objectstack#29935 — the spec materializes `refreshAfter: false` on an
+  // action authored without it, so the parsed shape is what reaches here.
+  it('a successful `operation: \'update\'` refreshes even with the parsed `refreshAfter: false`', async () => {
+    const onRefresh = vi.fn();
+    const handler = createServerActionHandler({ fetch: okFetch(), onRefresh });
+
+    const res = await handler({
+      type: 'script', name: 'resolve_ticket', operation: 'update', refreshAfter: false,
+      params: { recordId: 't1' },
+    } as ActionDef);
+    expect(res).toMatchObject({ success: true, reload: true });
+    expect(onRefresh).toHaveBeenCalledTimes(1);
+  });
+
+  it('a refused `operation: \'update\'` sends no refresh', async () => {
+    const onRefresh = vi.fn();
+    const fetch = vi.fn(async () => ({
+      ok: false,
+      status: 403,
+      json: async () => ({ success: false, error: { code: 'PERMISSION_DENIED', message: 'Denied' } }),
+    })) as unknown as ServerActionFetch;
+    const handler = createServerActionHandler({ fetch, onRefresh });
+
+    const res = await handler({
+      type: 'script', name: 'resolve_ticket', operation: 'update', refreshAfter: false,
+      params: { recordId: 't1' },
+    } as ActionDef);
+    expect(res.success).toBe(false);
+    expect(onRefresh).not.toHaveBeenCalled();
+  });
 });
 
 describe('createServerActionHandler — re-entrancy guard', () => {