@@ -276,6 +276,35 @@
  * resume consumed the suspension) withdraws Submit as the sections above say:
  * the run is over, and only a new run, or an operator's
  * `restore-suspension`, can accept input again.
+ *
+ * ## A result screen is acknowledged, never cancelled (objectstack#26902)
+ *
+ * A flow can end on a screen that only shows what it did: every field a
+ * `record_link` ({@link isDisplayOnlyScreen}), such as a lead conversion's
+ * last screen linking the account, contact and opportunity it created. That
+ * screen used to draw Cancel + Submit, and Cancel and the dialog close only
+ * dismissed the dialog: the run stayed suspended, `onComplete` never fired, so
+ * the page behind still showed the lead as it was before the conversion, and
+ * "Cancel" read as if it could undo records already written.
+ *
+ * So on such a screen the footer is one primary Done (`common.done`), and
+ * Done, the close button, Escape and a click outside all do the same thing:
+ * resume the run with no inputs (the engine refuses any value under a record
+ * link's name, and completes on the empty resume) and take the answer exactly
+ * as Submit does — the completion toast, `notifyDataChanged`, `onComplete`; a
+ * further screen if the run pauses again; the banner if the resume fails.
+ * While that resume is in flight the dialog cannot be dismissed, as on Submit.
+ * Once a resume has failed, closing goes back to a plain close: Done stays
+ * the retry, but an outage must never leave the user with a dialog that every
+ * way out answers by trying the same request again.
+ *
+ * It applies only where the screen is the end of the line. A display-only
+ * step the engine says another screen follows (`progress.nextScreen` other
+ * than `'none'`) keeps Cancel + Next: there Cancel abandons a wizard, which is
+ * still a real choice, and an X that resumed would open the next step instead
+ * of closing. A screen with no fields at all is not display-only either (see
+ * {@link isDisplayOnlyScreen}), and a terminal failure or a refusal keeps its
+ * single Close.
  */
 import { Suspense, useEffect, useState } from 'react';
 import {
@@ -304,6 +333,7 @@ import type { AutomationResult } from '@objectstack/spec/contracts';
 import { toast } from 'sonner';
 import {
   ScreenView,
+  isDisplayOnlyScreen,
   isObjectFormScreen,
   initialScreenValues,
   screenFieldBoundViolations,
@@ -736,9 +766,15 @@ export function FlowRunner({ state, authFetch, baseUrl, onClose, onComplete, dat
   const stepCounter = progress?.step !== undefined && progress.stepCount !== undefined
     ? t('form.stepOf', { current: progress.step, total: progress.stepCount, defaultValue: 'Step {{current}} of {{total}}' })
     : undefined;
+  // A last screen that only shows what the run did is acknowledged, not
+  // cancelled (objectstack#26902 — see the header): Done, and every way of
+  // closing the dialog, resumes the run exactly as Submit does — until a
+  // resume has failed, when closing is a plain close again and Done the retry.
+  const resultScreen = !terminal && !anotherScreen && isDisplayOnlyScreen(screen);
+  const dismiss = resultScreen && !resumeError ? () => { void submit(); } : onClose;
 
   return (
-    <Dialog open onOpenChange={(o) => { if (!o && !submitting) onClose(); }}>
+    <Dialog open onOpenChange={(o) => { if (!o && !submitting) dismiss(); }}>
       {/* Bounded on every screen (objectui#12080): a flex column at most 90vh
           tall, in which only the body below can give up height (`min-h-0`)
           and scroll, so the header and the footer always stay on screen. */}
@@ -829,6 +865,12 @@ export function FlowRunner({ state, authFetch, baseUrl, onClose, onComplete, dat
           <DialogFooter>
             {terminal ? (
               <Button variant="outline" onClick={onClose}>{t('common.close', { defaultValue: 'Close' })}</Button>
+            ) : resultScreen ? (
+              <Button onClick={submit} disabled={submitting}>
+                {submitting
+                  ? t('flowRunner.submitting', { defaultValue: 'Submitting…' })
+                  : t('common.done', { defaultValue: 'Done' })}
+              </Button>
             ) : (
               <>
                 <Button variant="outline" onClick={onClose} disabled={submitting}>{t('common.cancel', { defaultValue: 'Cancel' })}</Button>
 
@@ -155,6 +155,25 @@ export function isRecordLinkScreenField(field: ScreenFieldSpec): boolean {
   return field.type === SCREEN_FIELD_RECORD_LINK_TYPE;
 }
 
+/**
+ * Whether a screen only shows and collects nothing: a flat screen that declares
+ * at least one field, every one of them a record link — the one member of the
+ * spec's open `type` vocabulary that takes no input (objectstack#26902). It is
+ * the result screen a flow ends on, so the runtime answers it with Done rather
+ * than Cancel + Submit (`FlowRunner`).
+ *
+ * Read over the DECLARED fields, like the dialog's width, so the answer never
+ * changes while the screen is open. Two shapes are deliberately not display-only:
+ * - a screen with no fields at all — a message-only step can be the go-ahead for
+ *   what follows it ("Delete these records?"), so its Cancel has to stay a way out;
+ * - an `object-form` step, which writes a record and draws its own buttons.
+ */
+export function isDisplayOnlyScreen(screen: ScreenSpec): boolean {
+  if (isObjectFormScreen(screen)) return false;
+  const fields = screenFields(screen);
+  return fields.length > 0 && fields.every(isRecordLinkScreenField);
+}
+
 /** Whether a screen field is the upload widget — the widget hint, read as the renderer reads it. */
 function isFileScreenField(field: ScreenFieldSpec): boolean {
   return (field.type || '').toLowerCase() === 'file';
 
@@ -0,0 +1,240 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#26902 — a result screen is acknowledged, never cancelled.
+ *
+ * A screen flow that ends on a screen of read-only `type: 'record_link'`
+ * fields (a lead conversion's last screen, linking the account, contact and
+ * opportunity it created) used to draw Cancel + Submit, and Cancel and the
+ * dialog close only dismissed the dialog: the run stayed suspended and the
+ * host was never told to refresh, so the converted lead kept reading as it did
+ * before. On such a screen the footer is now one Done, and Done and every way
+ * of closing resume the run with no inputs and complete it as Submit does.
+ *
+ * Each leg that changes is held beside one that must not: a screen with an
+ * input keeps Cancel + Submit, a message-only screen keeps its Cancel, and a
+ * display-only step with another screen after it keeps Cancel + Next.
+ */
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor, cleanup } from '@testing-library/react';
+// Module scope, per ui/AGENTS.md 测试纪律: a record link reaches `LookupField`
+// through a `React.lazy` factory inside `@object-ui/fields`.
+import '@object-ui/fields';
+import { subscribeDataChanges, type DataChange } from '@object-ui/react';
+import { FlowRunner, type ScreenFlowState } from '../FlowRunner';
+import { isDisplayOnlyScreen, type ScreenSpec } from '../ScreenView';
+
+const toasts = vi.hoisted(() => ({ error: vi.fn(), success: vi.fn() }));
+vi.mock('sonner', () => ({ toast: toasts }));
+
+function fakeDataSource() {
+  return {
+    find: vi.fn(async () => ({ data: [] })),
+    findOne: vi.fn(async (_object: string, id: string) => ({ id, name: id })),
+    getObjectSchema: vi.fn(async (object: string) => ({ name: object, nameField: 'name', fields: { name: { type: 'text' } } })),
+  };
+}
+
+/** The HotCRM `lead_conversion` result screen: three links to the records the conversion created. */
+const LINKS: ScreenSpec['fields'] = [
+  { name: 'created_account', label: 'Account', type: 'record_link', reference: 'crm_account', defaultValue: 'acc_1' },
+  { name: 'created_contact', label: 'Contact', type: 'record_link', reference: 'crm_contact', defaultValue: 'con_2' },
+  { name: 'created_opportunity', label: 'Opportunity', type: 'record_link', reference: 'crm_opportunity', defaultValue: 'opp_3' },
+];
+
+function state(screenSpec: Partial<ScreenSpec> & { fields?: ScreenSpec['fields'] }): ScreenFlowState {
+  return {
+    flowName: 'lead_conversion',
+    runId: 'run-7',
+    screen: { nodeId: 'conversion_result', title: 'Lead converted', ...screenSpec },
+  };
+}
+
+const RESULT = state({ fields: LINKS, progress: { nextScreen: 'none', step: 2, stepCount: 2 } });
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
+}
+
+const completedResume = () =>
+  vi.fn(async (_url: string, _init?: RequestInit) => jsonResponse({ success: true, data: { success: true } }));
+
+function setup(flow: ScreenFlowState, authFetch = completedResume()) {
+  const onClose = vi.fn();
+  const onComplete = vi.fn();
+  render(
+    <FlowRunner
+      state={flow}
+      authFetch={authFetch}
+      baseUrl=""
+      onClose={onClose}
+      onComplete={onComplete}
+      dataSource={fakeDataSource()}
+      objects={[{ name: 'crm_account' }, { name: 'crm_contact' }, { name: 'crm_opportunity' }]}
+    />,
+  );
+  return { authFetch, onClose, onComplete };
+}
+
+/** Radix's own dismiss `X` — its accessible name is an `sr-only` "Close". */
+function dismissX(): HTMLElement {
+  const x = screen.getAllByRole('button', { name: 'Close' }).find((b) => b.querySelector('.sr-only') !== null);
+  expect(x, 'the dialog draws its dismiss X').toBeDefined();
+  return x as HTMLElement;
+}
+
+/** The resume POSTs `authFetch` received, each as `{ url, inputs }`. */
+function resumes(authFetch: ReturnType<typeof completedResume>) {
+  return authFetch.mock.calls.map(([url, init]) => ({ url, inputs: JSON.parse(String(init?.body)).inputs }));
+}
+
+const RESUME_URL = '/api/v1/automation/lead_conversion/runs/run-7/resume';
+
+let changes: DataChange[] = [];
+let unsubscribe: () => void = () => {};
+beforeEach(() => {
+  toasts.error.mockReset();
+  toasts.success.mockReset();
+  changes = [];
+  unsubscribe = subscribeDataChanges((change) => changes.push(change));
+});
+afterEach(() => {
+  unsubscribe();
+  cleanup();
+});
+
+describe('objectstack#26902 — a result screen is acknowledged, never cancelled', () => {
+  it('draws one Done on the lead_conversion result screen, and no Cancel or Submit', async () => {
+    setup(RESULT);
+    expect(await screen.findByRole('button', { name: 'Done' })).toBeEnabled();
+    expect(screen.queryByRole('button', { name: 'Cancel' })).toBeNull();
+    expect(screen.queryByRole('button', { name: 'Submit' })).toBeNull();
+  });
+
+  it('Done resumes the run with no inputs and completes it once, as Submit does', async () => {
+    const { authFetch, onClose, onComplete } = setup(RESULT);
+    fireEvent.click(await screen.findByRole('button', { name: 'Done' }));
+    await waitFor(() => expect(onComplete).toHaveBeenCalledTimes(1));
+    expect(resumes(authFetch)).toEqual([{ url: RESUME_URL, inputs: {} }]);
+    expect(onClose).not.toHaveBeenCalled();
+    expect(toasts.success).toHaveBeenCalledTimes(1);
+    expect(changes).toEqual([expect.objectContaining({ objectName: '*' })]);
+  });
+
+  it('the dialog close resumes and completes the run too — the X, and Escape', async () => {
+    const x = setup(RESULT);
+    fireEvent.click(dismissX());
+    await waitFor(() => expect(x.onComplete).toHaveBeenCalledTimes(1));
+    expect(resumes(x.authFetch)).toEqual([{ url: RESUME_URL, inputs: {} }]);
+    expect(x.onClose).not.toHaveBeenCalled();
+    cleanup();
+
+    const esc = setup(RESULT);
+    fireEvent.keyDown(await screen.findByRole('dialog'), { key: 'Escape' });
+    await waitFor(() => expect(esc.onComplete).toHaveBeenCalledTimes(1));
+    expect(resumes(esc.authFetch)).toEqual([{ url: RESUME_URL, inputs: {} }]);
+    expect(esc.onClose).not.toHaveBeenCalled();
+  });
+
+  it('a close while the resume is in flight posts nothing more', async () => {
+    let answer: (r: Response) => void = () => {};
+    const authFetch = vi.fn(() => new Promise<Response>((resolve) => { answer = resolve; }));
+    const { onComplete } = setup(RESULT, authFetch as unknown as ReturnType<typeof completedResume>);
+    fireEvent.click(await screen.findByRole('button', { name: 'Done' }));
+    await waitFor(() => expect(authFetch).toHaveBeenCalledTimes(1));
+    fireEvent.click(dismissX());
+    fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+    answer(jsonResponse({ success: true, data: { success: true } }));
+    await waitFor(() => expect(onComplete).toHaveBeenCalledTimes(1));
+    expect(authFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('a resume that pauses again draws the next screen, as Submit does', async () => {
+    const authFetch = vi.fn(async () =>
+      jsonResponse({
+        success: true,
+        data: { status: 'paused', runId: 'run-7', screen: { nodeId: 'follow_up', title: 'Schedule a follow-up', fields: [{ name: 'when', label: 'When', type: 'text' }] } },
+      }),
+    );
+    const { onClose, onComplete } = setup(state({ fields: LINKS }), authFetch as unknown as ReturnType<typeof completedResume>);
+    fireEvent.click(await screen.findByRole('button', { name: 'Done' }));
+    expect(await screen.findByText('Schedule a follow-up')).toBeInTheDocument();
+    // The next screen takes input, so it is back to Cancel + Submit.
+    expect(screen.getByRole('button', { name: 'Cancel' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Submit' })).toBeInTheDocument();
+    expect(onComplete).not.toHaveBeenCalled();
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('a failed resume keeps the screen and its banner, and a retryable one keeps Done', async () => {
+    const authFetch = vi.fn(async () => jsonResponse({ success: false, error: 'gateway timeout' }, 502));
+    const { onClose, onComplete } = setup(RESULT, authFetch as unknown as ReturnType<typeof completedResume>);
+    fireEvent.click(await screen.findByRole('button', { name: 'Done' }));
+    await waitFor(() => expect(toasts.error).toHaveBeenCalledTimes(1));
+    expect(screen.getByRole('alert')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Done' })).toBeEnabled();
+    expect(onComplete).not.toHaveBeenCalled();
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('after a failed resume the close only closes: an outage never traps the user in the dialog', async () => {
+    const authFetch = vi.fn(async () => jsonResponse({ success: false, error: 'gateway timeout' }, 502));
+    const { onClose, onComplete } = setup(RESULT, authFetch as unknown as ReturnType<typeof completedResume>);
+    fireEvent.click(await screen.findByRole('button', { name: 'Done' }));
+    await waitFor(() => expect(screen.getByRole('alert')).toBeInTheDocument());
+    expect(authFetch).toHaveBeenCalledTimes(1);
+    fireEvent.click(dismissX());
+    expect(onClose).toHaveBeenCalledTimes(1);
+    fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+    expect(onClose).toHaveBeenCalledTimes(2);
+    // Neither close resumed again; Done is still the retry.
+    expect(authFetch).toHaveBeenCalledTimes(1);
+    expect(screen.getByRole('button', { name: 'Done' })).toBeEnabled();
+    expect(onComplete).not.toHaveBeenCalled();
+  });
+
+  it('a screen with any input field keeps Cancel + Submit, and its Cancel only closes', async () => {
+    const { authFetch, onClose, onComplete } = setup(
+      state({ fields: [...LINKS!, { name: 'note', label: 'Note', type: 'text' }], progress: { nextScreen: 'none' } }),
+    );
+    expect(await screen.findByRole('button', { name: 'Submit' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Done' })).toBeNull();
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(onClose).toHaveBeenCalledTimes(1);
+    fireEvent.click(dismissX());
+    expect(onClose).toHaveBeenCalledTimes(2);
+    expect(authFetch).not.toHaveBeenCalled();
+    expect(onComplete).not.toHaveBeenCalled();
+  });
+
+  it('a message-only screen keeps its Cancel: it may be the go-ahead for what follows', async () => {
+    const { authFetch, onClose } = setup(state({ description: 'Delete these records?' }));
+    expect(await screen.findByRole('button', { name: 'Cancel' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Done' })).toBeNull();
+    fireEvent.click(dismissX());
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(authFetch).not.toHaveBeenCalled();
+  });
+
+  it('a display-only step with another screen after it keeps Cancel + Next', async () => {
+    const { authFetch, onClose } = setup(state({ fields: LINKS, progress: { nextScreen: 'certain', step: 2, stepCount: 3 } }));
+    expect(await screen.findByRole('button', { name: 'Next' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Done' })).toBeNull();
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(authFetch).not.toHaveBeenCalled();
+  });
+});
+
+describe('isDisplayOnlyScreen', () => {
+  it('holds only for a flat screen of one or more record links', () => {
+    expect(isDisplayOnlyScreen({ nodeId: 'r', fields: LINKS })).toBe(true);
+    expect(isDisplayOnlyScreen({ nodeId: 'r', fields: [LINKS![0]] })).toBe(true);
+    expect(isDisplayOnlyScreen({ nodeId: 'r', fields: [...LINKS!, { name: 'n', type: 'text' }] })).toBe(false);
+    // Matched exactly, as the engine's resume rule matches the member.
+    expect(isDisplayOnlyScreen({ nodeId: 'r', fields: [{ ...LINKS![0], type: 'Record_Link' }] })).toBe(false);
+    expect(isDisplayOnlyScreen({ nodeId: 'r', fields: [] })).toBe(false);
+    expect(isDisplayOnlyScreen({ nodeId: 'r' })).toBe(false);
+    expect(isDisplayOnlyScreen({ nodeId: 'r', kind: 'object-form', objectName: 'crm_account', fields: LINKS })).toBe(false);
+  });
+});