@object-ui/app-shell 6.2.2 → 7.0.0

package/dist/views/RecordDetailView.js

@@ -11,7 +11,7 @@ import { useParams, useNavigate, useLocation, Link } from 'react-router-dom';
 import { DetailView, RecordChatterPanel, buildDefaultPageSchema, extractMentions } from '@object-ui/plugin-detail';
 import { Empty, EmptyTitle, EmptyDescription } from '@object-ui/components';
 import { useAuth, createAuthenticatedFetch } from '@object-ui/auth';
-import { ActionProvider, useObjectTranslation, useObjectLabel, usePageAssignment, RecordContextProvider, SchemaRenderer, DiscussionContextProvider, HighlightFieldsProvider } from '@object-ui/react';
+import { ActionProvider, useObjectTranslation, useObjectLabel, usePageAssignment, RecordContextProvider, SchemaRenderer, DiscussionContextProvider, HighlightFieldsProvider, useGlobalUndo } from '@object-ui/react';
 import { buildExpandFields } from '@object-ui/core';
 import { toast } from 'sonner';
 import { useRecordPresence, PresenceAvatars } from '@object-ui/collaboration';
@@ -20,14 +20,18 @@ import { MetadataPanel, useMetadataInspector } from './MetadataInspector';
 import { SkeletonDetail } from '../skeletons';
 import { ManagedByBadge } from '../components/ManagedByBadge';
 import { resolveCrudAffordances } from '../utils/crudAffordances';
+import { deriveRelatedLists } from '../utils/deriveRelatedLists';
 import { hasExplicitDiscussion } from '../utils/pageSchemaIntrospect';
 import { ActionConfirmDialog } from './ActionConfirmDialog';
 import { ActionParamDialog } from './ActionParamDialog';
+import { ActionResultDialog } from './ActionResultDialog';
+import { FlowRunner } from './FlowRunner';
 import { resolveActionParams } from '../utils/resolveActionParams';
 import { useRecordBreadcrumbTitle } from '../context/NavigationContext';
 import { useRecordApprovals } from '../hooks/useRecordApprovals';
 import { getRecordDisplayName } from '../utils';
 import { useFavorites } from '../hooks/useFavorites';
+import { useActionModal } from '../hooks/useActionModal';
 import { useRecentItems } from '../hooks/useRecentItems';
 const FALLBACK_USER = { id: 'current-user', name: 'Demo User' };
 /**
@@ -79,13 +83,15 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     const location = useLocation();
     const originFrom = location.state?.from;
     const { t } = useObjectTranslation();
-    const { objectLabel, viewLabel: _vLabel, sectionLabel, actionLabel, actionConfirm, actionSuccess, fieldLabel, fieldOptionLabel } = useObjectLabel();
+    const { objectLabel, viewLabel: _vLabel, sectionLabel, actionLabel, actionConfirm, actionSuccess, actionParamText, actionParamOptionLabel, actionDescription, fieldLabel, fieldOptionLabel } = useObjectLabel();
     const { isFavorite, toggleFavorite, refreshLabel: refreshFavoriteLabel } = useFavorites();
     const { addRecentItem } = useRecentItems();
     const [isLoading, setIsLoading] = useState(true);
     const [feedItems, setFeedItems] = useState([]);
     const [mentionSuggestions, setMentionSuggestions] = useState([]);
     const [actionRefreshKey, setActionRefreshKey] = useState(0);
+    // Screen-flow runtime: a paused `screen`-node flow launched from a record action.
+    const [screenFlow, setScreenFlow] = useState(null);
     const [childRelatedData, setChildRelatedData] = useState({});
     const [historyEntries, setHistoryEntries] = useState(null);
     const [historyLoading, setHistoryLoading] = useState(false);
@@ -257,12 +263,18 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     const [confirmState, setConfirmState] = useState({ open: false, message: '' });
     // Param collection dialog state (promise-based)
     const [paramState, setParamState] = useState({ open: false, params: [] });
+    // Result-dialog state — one-shot reveal of action response data
+    // (2FA secrets, OAuth client_secret, recovery codes).
+    const [resultDialogState, setResultDialogState] = useState({ open: false });
+    const resultDialogHandler = useCallback((spec, data) => new Promise((resolve) => {
+        setResultDialogState({ open: true, spec, data, resolve });
+    }), []);
     const confirmHandler = useCallback((message, options) => {
         return new Promise((resolve) => {
             setConfirmState({ open: true, message, options, resolve });
         });
     }, []);
-    const paramCollectionHandler = useCallback((params) => {
+    const paramCollectionHandler = useCallback((params, action) => {
         return new Promise((resolve) => {
             const resolved = resolveActionParams(params, {
                 objectName: objectName || objectDef?.name || '',
@@ -270,15 +282,48 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 fieldLabel,
                 fieldOptionLabel,
             });
-            setParamState({ open: true, params: resolved, resolve });
+            // Localize param label/placeholder/helpText (see ObjectView for the
+            // convention); falls back to the metadata literal.
+            const objForI18n = objectName || objectDef?.name;
+            const localized = resolved.map((p) => ({
+                ...p,
+                label: actionParamText(objForI18n, action?.name, p.name, 'label', p.label) ?? p.label,
+                placeholder: actionParamText(objForI18n, action?.name, p.name, 'placeholder', p.placeholder) ?? p.placeholder,
+                helpText: actionParamText(objForI18n, action?.name, p.name, 'helpText', p.helpText) ?? p.helpText,
+                options: Array.isArray(p.options)
+                    ? p.options.map((o) => ({ ...o, label: actionParamOptionLabel(objForI18n, action?.name, p.name, o.value, o.label) }))
+                    : p.options,
+            }));
+            setParamState({
+                open: true,
+                params: localized,
+                // Title the dialog as the action rather than the generic "Action parameters".
+                title: action?.label || action?.title,
+                description: actionDescription(objForI18n, action?.name, action?.description),
+                resolve,
+            });
         });
-    }, [objectName, objectDef, objects, fieldLabel, fieldOptionLabel]);
+    }, [objectName, objectDef, objects, fieldLabel, fieldOptionLabel, actionParamText, actionParamOptionLabel]);
+    // Global undo/redo (Ctrl+Z), backed by the dataSource — the success toast's
+    // "Undo" button (for `undoable` actions) restores the record's prior values.
+    const undoCtl = useGlobalUndo({
+        dataSource,
+        onUndo: () => { setActionRefreshKey(k => k + 1); toast.success('Change undone'); },
+    });
     const toastHandler = useCallback((message, options) => {
-        if (options?.type === 'error')
+        if (options?.type === 'error') {
             toast.error(message);
-        else
-            toast.success(message);
-    }, []);
+            return;
+        }
+        if (options?.undo) {
+            toast.success(message, {
+                duration: options.duration,
+                action: { label: options.undo.label || 'Undo', onClick: () => { void undoCtl.undo(); } },
+            });
+            return;
+        }
+        toast.success(message, { duration: options?.duration });
+    }, [undoCtl]);
     const navigateHandler = useCallback((url, options) => {
         if (options?.external || options?.newTab) {
             window.open(url, '_blank', 'noopener,noreferrer');
@@ -291,7 +336,19 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     const apiHandler = useCallback(async (action) => {
         try {
             const target = action.target || action.name;
-            const params = action.params || {};
+            const params = { ...(action.params || {}) };
+            delete params._rowRecord;
+            // Merge `bodyExtra` constant fields into the update payload. Per the
+            // ActionSchema contract these are "applied last; overrides user params",
+            // and the PageView/list executeAPI path already honors them. Without this
+            // merge, a pure-confirm action (confirmText, no `params` array — the
+            // trigger carried entirely in `bodyExtra`) collects empty `params`, so the
+            // generic `default` branch below skips the update and the action silently
+            // no-ops on the record-detail page while working from a list row.
+            if (action.bodyExtra && typeof action.bodyExtra === 'object') {
+                Object.assign(params, action.bodyExtra);
+            }
+            let undo;
             switch (target) {
                 case 'opportunity_change_stage':
                     await dataSource.update(objectName, pureRecordId, { stage: params.new_stage });
@@ -305,6 +362,23 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 default:
                     // Generic: update record with collected params
                     if (Object.keys(params).length > 0) {
+                        // Undoable single-record update: capture the changed fields' prior
+                        // values from the loaded record so the success toast can offer Undo.
+                        if (action.undoable && pageRecord && objectName && pureRecordId) {
+                            const undoData = {};
+                            for (const k of Object.keys(params))
+                                undoData[k] = pageRecord[k] ?? null;
+                            undo = {
+                                id: `undo-${objectName}-${pureRecordId}-${Date.now()}`,
+                                type: 'update',
+                                objectName,
+                                recordId: String(pureRecordId),
+                                timestamp: Date.now(),
+                                description: action.label || `Undo ${objectName}`,
+                                undoData,
+                                redoData: { ...params },
+                            };
+                        }
                         await dataSource.update(objectName, pureRecordId, params);
                     }
                     break;
@@ -313,12 +387,20 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
             if (shouldRefresh) {
                 setActionRefreshKey(k => k + 1);
             }
-            return { success: true, reload: shouldRefresh };
+            else if (undo) {
+                // Even when refreshAfter isn't set, reflect the change so the user sees
+                // it (and the subsequent Undo) on the open record.
+                setActionRefreshKey(k => k + 1);
+            }
+            return { success: true, reload: shouldRefresh, undo };
         }
         catch (error) {
             return { success: false, error: error.message };
         }
-    }, [dataSource, objectName, pureRecordId]);
+    }, [dataSource, objectName, pureRecordId, pageRecord]);
+    // Client-side modal transport: `type:'modal'` actions open here (Dialog /
+    // Sheet / Drawer by `placement`) and render arbitrary SchemaNode content.
+    const { modalHandler, modalElement } = useActionModal(dataSource);
     // Authenticated fetch for direct backend calls (e.g. flow trigger).
     const authFetch = useMemo(() => createAuthenticatedFetch(), []);
     // Flow action handler — POST to /api/v1/automation/{name}/trigger.
@@ -347,6 +429,15 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 const errMsg = json?.error || `Flow "${flowName}" failed (HTTP ${res.status})`;
                 return { success: false, error: errMsg };
             }
+            // Screen-flow runtime: the run paused at a `screen` node awaiting input —
+            // open the FlowRunner to render the form + resume (refresh on completion).
+            const data = json?.data ?? {};
+            if (data.status === 'paused' && data.screen) {
+                setScreenFlow({ flowName, runId: data.runId, screen: data.screen });
+                // The action only OPENED the wizard — it hasn't completed. Suppress the
+                // action-level success toast; the flow-runner owns completion messaging.
+                return { success: true, silent: true };
+            }
             const shouldRefresh = action.refreshAfter !== false;
             if (shouldRefresh) {
                 setActionRefreshKey(k => k + 1);
@@ -362,6 +453,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     // server-registered handler name (engine.registerAction). Sends the
     // current recordId, objectName, and any collected/static params, and the
     // server resolves the handler (with wildcard '*' fallback) and runs it.
+    const serverActionInFlight = useRef(new Set());
     const serverActionHandler = useCallback(async (action) => {
         const targetName = action.target || action.name;
         if (!targetName) {
@@ -370,6 +462,12 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
         const params = (action.params && !Array.isArray(action.params))
             ? action.params
             : {};
+        // Re-entrancy guard: ignore a repeat click while this action+record runs.
+        const inflightKey = `${targetName}:${pureRecordId ?? ''}`;
+        if (serverActionInFlight.current.has(inflightKey)) {
+            return { success: false, error: 'Action already in progress' };
+        }
+        serverActionInFlight.current.add(inflightKey);
         // ── Popup-blocker workaround ──────────────────────────────────────
         // When `action.opensInNewTab` is set, the handler is known to return
         // `{ redirectUrl: ... }` for the UI to navigate to. We pre-open
@@ -381,8 +479,20 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
         // the user always gets there.
         let preOpenedTab = null;
         if (action.opensInNewTab) {
+            // NOTE: do NOT pass 'noopener' here — per spec it forces window.open to
+            // return null even when the tab opens, so we'd lose the handle, fall
+            // through to the popup branch below, and end up navigating the *current*
+            // tab to the redirectUrl (the double-navigation bug: env opens in a new
+            // tab AND the list/detail page jumps to the now-consumed SSO URL). We
+            // need the reference to drive the pre-opened tab to the SSO redirect.
             try {
-                preOpenedTab = window.open('about:blank', '_blank', 'noopener,noreferrer');
+                preOpenedTab = window.open('about:blank', '_blank');
+                // Paint progress immediately so the new tab isn't blank/frozen during
+                // the (slow) SSO-handoff mint.
+                if (preOpenedTab) {
+                    preOpenedTab.document.write('<!doctype html><meta charset="utf-8"><title>正在打开… Opening…</title><body style="margin:0;font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;gap:16px;color:#4b5563"><div style="width:28px;height:28px;border:3px solid #e5e7eb;border-top-color:#6366f1;border-radius:50%;animation:s .8s linear infinite"></div><div>正在为你打开环境…</div><style>@keyframes s{to{transform:rotate(360deg)}}</style></body>');
+                    preOpenedTab.document.close();
+                }
             }
             catch {
                 preOpenedTab = null;
@@ -390,6 +500,63 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
         }
         try {
             const baseUrl = import.meta.env.VITE_SERVER_URL || '';
+            // ── Zero-roundtrip fast path ────────────────────────────────────────
+            // `newTabUrl` names a GET endpoint that performs ALL auth/authz itself
+            // (e.g. /sso-open re-runs every check the POST half would have done),
+            // so the POST round trip would add nothing but click latency. Drive the
+            // pre-opened tab there immediately — the spinner page stays painted
+            // until the (possibly slow) endpoint commits its redirect.
+            const newTabUrl = typeof action.newTabUrl === 'string' ? action.newTabUrl : '';
+            if (action.opensInNewTab && newTabUrl) {
+                if (pureRecordId == null) {
+                    if (preOpenedTab) {
+                        try {
+                            preOpenedTab.close();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    return { success: false, error: 'This action runs on a single record — no record id available.' };
+                }
+                // Absolute URL required: the pre-opened tab is an about:blank document,
+                // so a bare-relative href has no reliable resolution base.
+                const directUrl = `${baseUrl || window.location.origin}${newTabUrl.replace('{recordId}', encodeURIComponent(String(pureRecordId)))}`;
+                if (preOpenedTab) {
+                    try {
+                        preOpenedTab.location.href = directUrl;
+                    }
+                    catch {
+                        try {
+                            preOpenedTab.close();
+                        }
+                        catch { /* ignore */ }
+                        window.location.href = directUrl;
+                    }
+                }
+                else {
+                    let popup = null;
+                    try {
+                        popup = window.open(directUrl, '_blank');
+                    }
+                    catch {
+                        popup = null;
+                    }
+                    if (!popup) {
+                        toast('浏览器拦截了弹窗 / Popup blocked', {
+                            description: '点击在新标签页打开环境',
+                            action: { label: '打开环境', onClick: () => { try {
+                                    window.open(directUrl, '_blank');
+                                }
+                                catch {
+                                    window.location.href = directUrl;
+                                } } },
+                            duration: 10000,
+                        });
+                    }
+                }
+                if (action.refreshAfter === true)
+                    setActionRefreshKey(k => k + 1);
+                return { success: true };
+            }
             const obj = action.objectName || objectName || 'global';
             const res = await authFetch(`${baseUrl}/api/v1/actions/${encodeURIComponent(obj)}/${encodeURIComponent(targetName)}`, {
                 method: 'POST',
@@ -397,14 +564,25 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 body: JSON.stringify({ recordId: pureRecordId, params }),
             });
             const json = await res.json().catch(() => null);
-            if (!res.ok || (json && json.success === false)) {
-                const errMsg = json?.error || `Action "${targetName}" failed (HTTP ${res.status})`;
+            // The action route wraps the handler's return value in a {success, data}
+            // envelope. A script action that THROWS is reported as
+            // `data: { success: false, error }` while the OUTER success stays true,
+            // so we must inspect the inner envelope too — otherwise a failed action
+            // is mistaken for success and fires the green "completed" toast while the
+            // real error is swallowed.
+            const inner = json?.data;
+            const innerFailed = inner && typeof inner === 'object' && inner.success === false;
+            if (!res.ok || (json && json.success === false) || innerFailed) {
+                const errMsg = (innerFailed && inner.error) || json?.error || `Action "${targetName}" failed (HTTP ${res.status})`;
                 if (preOpenedTab) {
                     try {
                         preOpenedTab.close();
                     }
                     catch { /* ignore */ }
                 }
+                // Surface the failure — this custom new-tab path bypasses
+                // ActionRunner's toast-on-error, so otherwise the user gets no feedback.
+                toast.error(errMsg);
                 return { success: false, error: errMsg };
             }
             const shouldRefresh = action.refreshAfter !== false;
@@ -434,14 +612,26 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 }
                 else {
                     let popup = null;
+                    // No 'noopener' so a successful open returns a truthy handle; with
+                    // it, the null return would always trip the current-tab fallback.
                     try {
-                        popup = window.open(redirectUrl, '_blank', 'noopener,noreferrer');
+                        popup = window.open(redirectUrl, '_blank');
                     }
                     catch {
                         popup = null;
                     }
                     if (!popup) {
-                        window.location.href = redirectUrl;
+                        // Don't silently hijack the current tab — offer a one-click open.
+                        toast('浏览器拦截了弹窗 / Popup blocked', {
+                            description: '点击在新标签页打开环境',
+                            action: { label: '打开环境', onClick: () => { try {
+                                    window.open(redirectUrl, '_blank');
+                                }
+                                catch {
+                                    window.location.href = redirectUrl;
+                                } } },
+                            duration: 10000,
+                        });
                     }
                 }
             }
@@ -462,13 +652,19 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 }
                 catch { /* ignore */ }
             }
-            return { success: false, error: error.message };
+            const msg = error.message;
+            toast.error(msg);
+            return { success: false, error: msg };
+        }
+        finally {
+            serverActionInFlight.current.delete(inflightKey);
         }
     }, [authFetch, pureRecordId, objectName]);
     // ─── Approvals ─────────────────────────────────────────────────────
-    // Surfaces "Submit for Approval" / "Recall" buttons on the record header
-    // when an active approval process is registered for this object, and a
-    // status badge when a request exists.
+    // Since ADR-0019 an approval is a flow node: the flow opens the request,
+    // there is no manual submit/recall from the record header. When the current
+    // user is a pending approver, surface "Approve" / "Reject" on the header and
+    // a status badge whenever a request exists.
     const approvals = useRecordApprovals(objectName, pureRecordId, user?.id);
     // Hold latest approvals snapshot in a ref so the action handler
     // (memoized once inside ActionRunner) always sees fresh state instead of
@@ -481,14 +677,11 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
             ? action.params
             : {};
         try {
-            if (target === 'submit_approval') {
-                await approvalsRef.current.submit({
-                    processName: params.processName,
-                    comment: params.comment,
-                });
+            if (target === 'approve_request') {
+                await approvalsRef.current.approve({ comment: params.comment });
             }
-            else if (target === 'recall_approval') {
-                await approvalsRef.current.recall({ comment: params.comment });
+            else if (target === 'reject_request') {
+                await approvalsRef.current.reject({ comment: params.comment });
             }
             else {
                 return { success: false, error: `Unknown approval target: ${target}` };
@@ -502,29 +695,36 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     }, []);
     // Discover reverse references: other objects with lookup/master_detail fields
     // pointing to the current object (e.g., order_item.order → order).
-    const childRelations = useMemo(() => {
-        if (!objectDef || !objects)
-            return [];
-        const relations = [];
-        for (const obj of objects) {
-            if (obj.name === objectDef.name)
-                continue;
-            for (const [fieldName, fieldDef] of Object.entries(obj.fields || {})) {
-                if (fieldDef &&
-                    (fieldDef.type === 'lookup' || fieldDef.type === 'master_detail') &&
-                    (fieldDef.reference_to || fieldDef.reference) === objectDef.name) {
-                    relations.push({
-                        childObject: obj.name,
-                        childLabel: obj.label || obj.name,
-                        referenceField: fieldName,
-                    });
-                }
-            }
-        }
-        return relations;
-    }, [objectDef, objects]);
-    // Fetch related child records for each reverse reference
+    //
+    // Audit FKs (`created_by` / `updated_by` / `owner_id`) are skipped — they
+    // exist on virtually every object, and on a `sys_user` page they would
+    // produce one related entry per (object × audit-FK) pair (dozens of
+    // duplicate "用户偏好 / 邮件模板 / 角色 …" cards in the right rail and
+    // tabs). The semantic owner field for a child record is its primary
+    // `*_id` lookup; audit attribution belongs in audit views, not in the
+    // related-records summary.
+    // Detail-page related lists — the read-side mirror of the form's inline
+    // master-detail. Derived purely from the relationship graph: every child
+    // object whose lookup/master_detail FK references this object becomes a
+    // related list (owned `master_detail` children first), unless its FK opts
+    // out via `relatedList: false`. `relatedListTitle` / `relatedListColumns`
+    // on the FK override the derived title / columns. Audit FKs are skipped and
+    // children deduped — see `deriveRelatedLists`.
+    const childRelations = useMemo(() => deriveRelatedLists(objectDef, objects), [objectDef, objects]);
+    // Fetch related child records for each reverse reference.
+    //
+    // PERF: only the legacy `DetailView` path consumes `childRelatedData`
+    // (it's threaded into `detailSchema.related[].data`). The default
+    // schema path renders each related list via `record:related_list`,
+    // whose `RelatedList` self-fetches lazily when its tab is shown — so
+    // preloading here would just fire ~N redundant concurrent queries on
+    // every record open (measured: a record with 8 related lists fired ~50
+    // concurrent requests, all TTFB ~9s) for data the schema path never
+    // reads. Skip the fan-out entirely whenever the schema page renders;
+    // load eagerly only for the legacy fallback that needs it.
     useEffect(() => {
+        if (effectivePage)
+            return;
         if (!dataSource || !pureRecordId || childRelations.length === 0)
             return;
         let cancelled = false;
@@ -548,7 +748,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
             setChildRelatedData(data);
         });
         return () => { cancelled = true; };
-    }, [dataSource, pureRecordId, childRelations]);
+    }, [dataSource, pureRecordId, childRelations, objectDef, effectivePage]);
     // ── Audit history fetch ────────────────────────────────────────────
     // Loads recent sys_audit_log entries for this record so the DetailView can
     // render a read-only "History" tab. Gated on three preconditions to keep
@@ -777,7 +977,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
             const mapped = res.data.map((c) => ({
                 id: c.id,
                 type: 'comment',
-                actor: c.author_name ?? 'Unknown',
+                actor: c.author_name ?? t('detail.unknownUser', { defaultValue: 'Unknown' }),
                 actorAvatarUrl: c.author_avatar_url ?? undefined,
                 body: c.body ?? '',
                 createdAt: c.created_at,
@@ -838,8 +1038,8 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 return;
             const mapped = [];
             for (const row of res.data) {
-                const t = activityTypeToFeed[row.type];
-                if (!t)
+                const feedType = activityTypeToFeed[row.type];
+                if (!feedType)
                     continue;
                 // Prefer the explicit `timestamp` column, but tolerate older
                 // rows where the driver leaked the literal "NOW()" — fall
@@ -850,11 +1050,15 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 }
                 mapped.push({
                     id: row.id,
-                    type: t,
-                    actor: row.actor_name ?? 'System',
+                    type: feedType,
+                    actor: row.actor_name ?? t('detail.systemActor', { defaultValue: 'System' }),
                     actorAvatarUrl: row.actor_avatar_url ?? undefined,
                     body: row.summary ?? '',
                     createdAt: when,
+                    // ADR-0052 ActivityPointer: drill from the summary to the source
+                    // rich entity (sys_email row, call/meeting task, …) when present.
+                    sourceObject: row.source_object ?? undefined,
+                    sourceId: row.source_id ?? undefined,
                 });
             }
             if (!mapped.length)
@@ -878,11 +1082,12 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
     }, [dataSource, objectName, pureRecordId, currentUser]);
     /**
      * Note: comment-mention → notification fan-out lives on the server
-     * (`@objectstack/plugin-audit` registers a `sys_comment` afterInsert
-     * hook that parses the `mentions` JSON and writes one `sys_notification`
-     * row per recipient). The client's only job is to ensure
+     * (`@objectstack/plugin-audit` registers a `sys_comment` afterInsert hook
+     * that parses the `mentions` JSON and calls `messaging.emit('collab.mention')`
+     * — ADR-0030 single ingress — which materializes one `sys_inbox_message` per
+     * recipient that the bell then reads). The client's only job is to ensure
      * `sys_comment.mentions` carries the real id list (see handleAddComment
-     * /handleAddReply below). Deployments without plugin-audit will not
+     * /handleAddReply below). Deployments without the messaging pipeline will not
      * deliver bell notifications, which is the expected degradation.
      */
     const handleAddComment = useCallback(async (text) => {
@@ -1126,57 +1331,44 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                     successMessage: actionSuccess(objectDef.name, a.name, a.successMessage),
                 }),
             }));
-            // Inject approval actions — only when the approvals plugin is
-            // available and an active process exists for this object.
-            if (approvals.available && approvals.processes.length > 0) {
-                if (approvals.canSubmit) {
-                    base.push({
-                        name: 'submit_approval',
-                        type: 'approval',
-                        target: 'submit_approval',
-                        label: t('approvals.submitForApproval', { defaultValue: 'Submit for Approval' }),
-                        icon: 'send',
-                        variant: 'default',
-                        locations: ['record_header'],
-                        refreshAfter: true,
-                        successMessage: t('approvals.submitSuccess', { defaultValue: 'Approval request submitted' }),
-                        ...(approvals.processes.length === 1
-                            ? { params: { processName: approvals.processes[0].name } }
-                            : {
-                                collectParams: [{
-                                        name: 'processName',
-                                        label: t('approvals.process', { defaultValue: 'Process' }),
-                                        type: 'select',
-                                        required: true,
-                                        options: approvals.processes.map((p) => ({
-                                            value: p.name,
-                                            label: p.label || p.name,
-                                        })),
-                                    }, {
-                                        name: 'comment',
-                                        label: t('approvals.comment', { defaultValue: 'Comment (optional)' }),
-                                        type: 'text',
-                                        multiline: true,
-                                    }],
-                            }),
-                    });
-                }
-                if (approvals.canRecall) {
-                    base.push({
-                        name: 'recall_approval',
-                        type: 'approval',
-                        target: 'recall_approval',
-                        label: t('approvals.recall', { defaultValue: 'Recall' }),
-                        icon: 'undo',
-                        variant: 'outline',
-                        locations: ['record_header'],
-                        refreshAfter: true,
-                        confirmText: t('approvals.recallConfirm', {
-                            defaultValue: 'Recall this pending approval request?',
-                        }),
-                        successMessage: t('approvals.recallSuccess', { defaultValue: 'Approval recalled' }),
-                    });
-                }
+            // Inject approval actions — only when the current user is a pending
+            // approver for this record (ADR-0019: approvals are opened by a flow
+            // node, so there is no manual submit/recall; an approver records a
+            // decision that resumes the flow down its approve/reject edge).
+            if (approvals.available && approvals.canDecide) {
+                const commentParam = {
+                    name: 'comment',
+                    label: t('approvals.comment', { defaultValue: 'Comment (optional)' }),
+                    type: 'text',
+                    multiline: true,
+                };
+                base.push({
+                    name: 'approve_request',
+                    type: 'approval',
+                    target: 'approve_request',
+                    label: t('approvals.approve', { defaultValue: 'Approve' }),
+                    icon: 'check',
+                    variant: 'default',
+                    locations: ['record_header'],
+                    refreshAfter: true,
+                    collectParams: [commentParam],
+                    successMessage: t('approvals.approveSuccess', { defaultValue: 'Approved' }),
+                });
+                base.push({
+                    name: 'reject_request',
+                    type: 'approval',
+                    target: 'reject_request',
+                    label: t('approvals.reject', { defaultValue: 'Reject' }),
+                    icon: 'x',
+                    variant: 'destructive',
+                    locations: ['record_header'],
+                    refreshAfter: true,
+                    confirmText: t('approvals.rejectConfirm', {
+                        defaultValue: 'Reject this approval request?',
+                    }),
+                    collectParams: [commentParam],
+                    successMessage: t('approvals.rejectSuccess', { defaultValue: 'Rejected' }),
+                });
             }
             return base;
         })();
@@ -1191,12 +1383,15 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
         // surfaces as header `+ New` / `View All` buttons and per-row Edit /
         // Delete controls.
         const baseAppUrl = appName ? `/apps/${appName}` : '';
-        const related = childRelations.map(({ childObject, childLabel, referenceField }) => {
+        const related = childRelations.map(({ childObject, childLabel, referenceField, title: titleOverride, columns: columnsOverride }) => {
             const childObjectDef = objects.find((o) => o.name === childObject);
             const parentId = pureRecordId || '';
-            const localizedTitle = childObjectDef
-                ? objectLabel({ name: childObjectDef.name, label: childObjectDef.label || childLabel })
-                : childLabel;
+            // A `relatedListTitle` on the relationship wins; else fall back to the
+            // localized child-object label.
+            const localizedTitle = titleOverride
+                || (childObjectDef
+                    ? objectLabel({ name: childObjectDef.name, label: childObjectDef.label || childLabel })
+                    : childLabel);
             const buildNewUrl = () => {
                 const qs = new URLSearchParams({ [referenceField]: parentId }).toString();
                 return `${baseAppUrl}/${childObject}/new${qs ? `?${qs}` : ''}`;
@@ -1263,7 +1458,20 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 api: childObject,
                 data: childRelatedData[childObject] || [],
                 referenceField,
+                // Explicit columns from `relatedListColumns` on the relationship; when
+                // absent the related-list renderer auto-derives them from the child
+                // object's fields.
+                ...(Array.isArray(columnsOverride) && columnsOverride.length > 0
+                    ? { columns: columnsOverride }
+                    : {}),
                 icon: childObjectDef?.icon,
+                // Surface the child object's canonical display field so the
+                // right-rail can show meaningful labels (`user_agent`, `email`,
+                // …) instead of opaque IDs like `kCc8mhJr0bRs0r9Ykd09…`.
+                displayField: childObjectDef?.displayNameField ||
+                    (Array.isArray(childObjectDef?.compactLayout)
+                        ? childObjectDef.compactLayout[0]
+                        : undefined),
                 onNew,
                 onViewAll,
                 onRowClick,
@@ -1307,7 +1515,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
             }),
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [objectDef?.name, pureRecordId, childRelatedData, actionRefreshKey, appName, navigate, dataSource, t, objectLabel, objects, historyEnabled, historyEntries, historyLoading, approvals.available, approvals.processes, approvals.canSubmit, approvals.canRecall, approvals.pendingRequest, approvals.latestRequest, embedded]);
+    }, [objectDef?.name, pureRecordId, childRelatedData, actionRefreshKey, appName, navigate, dataSource, t, objectLabel, objects, historyEnabled, historyEntries, historyLoading, approvals.available, approvals.canDecide, approvals.pendingRequest, approvals.latestRequest, embedded]);
     if (isLoading) {
         return _jsx(SkeletonDetail, {});
     }
@@ -1489,51 +1697,58 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                 // Per-object opt-outs read from `objectDef.detail.*`. Lets
                 // catalog/atomic objects (product, task, ...) keep a focused
                 // single-column layout instead of inheriting the rail.
+                showReferenceRail: objectDef?.detail?.showReferenceRail === true || undefined,
                 hideReferenceRail: objectDef?.detail?.hideReferenceRail === true || undefined,
                 hideRelatedTab: objectDef?.detail?.hideRelatedTab === true || undefined,
                 ...(assignedSlots ? { slots: assignedSlots } : {}),
             });
-        return (_jsxs("div", { className: "h-full bg-background overflow-hidden flex flex-col relative", children: [_jsxs("div", { className: "absolute top-2 sm:top-4 right-2 sm:right-4 z-50 flex items-center gap-2", children: [recordPresence.length > 0 && (_jsx(PresenceAvatars, { users: recordPresence, size: "sm", maxVisible: 3, showStatus: true })), _jsx(ManagedByBadge, { managedBy: objectDef?.managedBy })] }), _jsx(RecordContextProvider, { objectName: objectName, recordId: pureRecordId, data: pageRecord, objectSchema: objectDef, dataSource: dataSource, embedded: embedded, headerSystemActions: synthSystemActions, isFavorite: isRecordFavorite, onToggleFavorite: favoriteRecord ? handleToggleRecordFavorite : undefined, children: _jsx(HighlightFieldsProvider, { children: _jsx(DiscussionContextProvider, { items: feedItems, onAddComment: handleAddComment, onAddReply: handleAddReply, onToggleReaction: handleToggleReaction, mentionSuggestions: mentionSuggestions, children: _jsx(ActionProvider, { context: { record: pageRecord || {}, objectName, user: currentUser }, onConfirm: confirmHandler, onToast: toastHandler, onNavigate: navigateHandler, onParamCollection: paramCollectionHandler, handlers: { api: apiHandler, flow: flowHandler, script: serverActionHandler, modal: serverActionHandler, approval: approvalHandler }, children: _jsxs("div", { className: "flex-1 overflow-hidden flex flex-row", children: [_jsxs("div", { className: "flex-1 overflow-auto p-3 sm:p-4 lg:p-6 scroll-pb-48", children: [originFrom?.pathname && originFrom?.label && (_jsxs(Link, { to: originFrom.pathname, className: "inline-flex items-center gap-1 mb-3 text-sm text-muted-foreground hover:text-foreground transition-colors", children: [_jsx(ChevronLeft, { className: "h-4 w-4" }), _jsx("span", { children: originFrom.label })] })), _jsx(SchemaRenderer, { schema: renderedPage }), showAutoDiscussion && (_jsx("div", { className: "mt-6", children: _jsx(RecordChatterPanel, { config: {
-                                                            position: 'bottom',
-                                                            collapsible: false,
-                                                            feed: {
-                                                                enableReactions: true,
-                                                                enableThreading: true,
-                                                                showCommentInput: true,
-                                                            },
-                                                        }, items: feedItems, onAddComment: handleAddComment, onAddReply: handleAddReply, onToggleReaction: handleToggleReaction, mentionSuggestions: mentionSuggestions }) }))] }), _jsx(MetadataPanel, { open: showDebug, sections: [{ title: 'Page Schema', data: renderedPage }] })] }) }) }) }) }), _jsx(ActionConfirmDialog, { state: confirmState, onOpenChange: (open) => {
+        return (_jsxs("div", { className: "h-full bg-background overflow-hidden flex flex-col relative", children: [_jsxs("div", { className: "absolute top-2 sm:top-4 right-2 sm:right-4 z-50 flex items-center gap-2", children: [recordPresence.length > 0 && (_jsx(PresenceAvatars, { users: recordPresence, size: "sm", maxVisible: 3, showStatus: true })), _jsx(ManagedByBadge, { managedBy: objectDef?.managedBy })] }), _jsx(RecordContextProvider, { objectName: objectName, recordId: pureRecordId, data: pageRecord, objectSchema: objectDef, dataSource: dataSource, embedded: embedded, headerSystemActions: synthSystemActions, isFavorite: isRecordFavorite, onToggleFavorite: favoriteRecord ? handleToggleRecordFavorite : undefined, children: _jsx(HighlightFieldsProvider, { children: _jsx(DiscussionContextProvider, { items: feedItems, onAddComment: handleAddComment, onAddReply: handleAddReply, onToggleReaction: handleToggleReaction, mentionSuggestions: mentionSuggestions, children: _jsxs(ActionProvider, { context: { record: pageRecord || {}, objectName, user: currentUser }, onConfirm: confirmHandler, onToast: toastHandler, onNavigate: navigateHandler, onParamCollection: paramCollectionHandler, onResultDialog: resultDialogHandler, onModal: modalHandler, handlers: { api: apiHandler, flow: flowHandler, script: serverActionHandler, approval: approvalHandler }, children: [_jsxs("div", { className: "flex-1 overflow-hidden flex flex-row", children: [_jsxs("div", { className: "flex-1 overflow-auto p-3 sm:p-4 lg:p-6 scroll-pb-48", children: [originFrom?.pathname && originFrom?.label && (_jsxs(Link, { to: originFrom.pathname, className: "inline-flex items-center gap-1 mb-3 text-sm text-muted-foreground hover:text-foreground transition-colors", children: [_jsx(ChevronLeft, { className: "h-4 w-4" }), _jsx("span", { children: originFrom.label })] })), _jsx(SchemaRenderer, { schema: renderedPage }), showAutoDiscussion && (_jsx("div", { className: "mt-6", children: _jsx(RecordChatterPanel, { config: {
+                                                                position: 'bottom',
+                                                                collapsible: false,
+                                                                feed: {
+                                                                    enableReactions: true,
+                                                                    enableThreading: true,
+                                                                    showCommentInput: true,
+                                                                },
+                                                            }, items: feedItems, onAddComment: handleAddComment, onAddReply: handleAddReply, onToggleReaction: handleToggleReaction, mentionSuggestions: mentionSuggestions }) }))] }), _jsx(MetadataPanel, { open: showDebug, sections: [{ title: 'Page Schema', data: renderedPage }] })] }), modalElement] }) }) }) }), _jsx(ActionConfirmDialog, { state: confirmState, onOpenChange: (open) => {
                         if (!open)
                             setConfirmState(s => ({ ...s, open: false }));
                     } }), _jsx(ActionParamDialog, { state: paramState, onOpenChange: (open) => {
                         if (!open)
                             setParamState(s => ({ ...s, open: false }));
-                    } })] }));
+                    } }), _jsx(ActionResultDialog, { state: resultDialogState, onAcknowledge: () => {
+                        resultDialogState.resolve?.();
+                        setResultDialogState({ open: false });
+                    } }), _jsx(FlowRunner, { state: screenFlow, authFetch: authFetch, baseUrl: import.meta.env.VITE_SERVER_URL || '', dataSource: dataSource, objects: objects, onClose: () => setScreenFlow(null), onComplete: () => { setScreenFlow(null); setActionRefreshKey(k => k + 1); } })] }));
     }
-    return (_jsxs("div", { className: "h-full bg-background overflow-hidden flex flex-col relative", children: [_jsxs("div", { className: "absolute top-2 sm:top-4 right-2 sm:right-4 z-50 flex items-center gap-2", children: [recordPresence.length > 0 && (_jsx(PresenceAvatars, { users: recordPresence, size: "sm", maxVisible: 3, showStatus: true })), _jsx(ManagedByBadge, { managedBy: objectDef?.managedBy })] }), _jsxs("div", { className: "flex-1 overflow-hidden flex flex-row", children: [_jsx("div", { className: "flex-1 overflow-auto p-3 sm:p-4 lg:p-6 scroll-pb-48", children: _jsx(ActionProvider, { context: { record: {}, objectName, user: currentUser }, onConfirm: confirmHandler, onToast: toastHandler, onNavigate: navigateHandler, onParamCollection: paramCollectionHandler, handlers: { api: apiHandler, flow: flowHandler, script: serverActionHandler, modal: serverActionHandler, approval: approvalHandler }, children: _jsx(DetailView, { schema: detailSchema, dataSource: dataSource, objectLabel: objectLabel({ name: objectDef.name, label: objectDef.label }), isFavorite: isRecordFavorite, onToggleFavorite: favoriteRecord ? handleToggleRecordFavorite : undefined, onDataLoaded: (record) => {
-                                    if (!record || typeof record !== 'object')
-                                        return;
-                                    // Resolve the same way DetailView's header does, so the
-                                    // breadcrumb matches the on-page title (e.g. "David Kim"
-                                    // instead of "#lead-1778…").
-                                    const resolved = getRecordDisplayName(objectDef, record);
-                                    if (resolved && resolved !== recordTitle && resolved !== 'Untitled') {
-                                        setRecordTitle(resolved);
-                                    }
-                                }, onEdit: () => {
-                                    onEdit({ id: pureRecordId });
-                                }, discussionSlot: _jsx(RecordChatterPanel, { config: {
-                                        position: 'bottom',
-                                        collapsible: false,
-                                        feed: {
-                                            enableReactions: true,
-                                            enableThreading: true,
-                                            showCommentInput: true,
-                                        },
-                                    }, items: feedItems, onAddComment: handleAddComment, onAddReply: handleAddReply, onToggleReaction: handleToggleReaction }) }, actionRefreshKey) }) }), _jsx(MetadataPanel, { open: showDebug, sections: [{ title: 'View Schema', data: detailSchema }] })] }), _jsx(ActionConfirmDialog, { state: confirmState, onOpenChange: (open) => {
+    return (_jsxs("div", { className: "h-full bg-background overflow-hidden flex flex-col relative", children: [_jsxs("div", { className: "absolute top-2 sm:top-4 right-2 sm:right-4 z-50 flex items-center gap-2", children: [recordPresence.length > 0 && (_jsx(PresenceAvatars, { users: recordPresence, size: "sm", maxVisible: 3, showStatus: true })), _jsx(ManagedByBadge, { managedBy: objectDef?.managedBy })] }), _jsxs("div", { className: "flex-1 overflow-hidden flex flex-row", children: [_jsx("div", { className: "flex-1 overflow-auto p-3 sm:p-4 lg:p-6 scroll-pb-48", children: _jsx("div", { className: "mx-auto w-full max-w-[1400px]", children: _jsxs(ActionProvider, { context: { record: {}, objectName, user: currentUser }, onConfirm: confirmHandler, onToast: toastHandler, onNavigate: navigateHandler, onParamCollection: paramCollectionHandler, onResultDialog: resultDialogHandler, onModal: modalHandler, handlers: { api: apiHandler, flow: flowHandler, script: serverActionHandler, approval: approvalHandler }, children: [_jsx(DetailView, { schema: detailSchema, dataSource: dataSource, objectLabel: objectLabel({ name: objectDef.name, label: objectDef.label }), isFavorite: isRecordFavorite, onToggleFavorite: favoriteRecord ? handleToggleRecordFavorite : undefined, onDataLoaded: (record) => {
+                                            if (!record || typeof record !== 'object')
+                                                return;
+                                            // Resolve the same way DetailView's header does, so the
+                                            // breadcrumb matches the on-page title (e.g. "David Kim"
+                                            // instead of "#lead-1778…").
+                                            const resolved = getRecordDisplayName(objectDef, record);
+                                            if (resolved && resolved !== recordTitle && resolved !== 'Untitled') {
+                                                setRecordTitle(resolved);
+                                            }
+                                        }, onEdit: () => {
+                                            onEdit({ id: pureRecordId });
+                                        }, discussionSlot: _jsx(RecordChatterPanel, { config: {
+                                                position: 'bottom',
+                                                collapsible: false,
+                                                feed: {
+                                                    enableReactions: true,
+                                                    enableThreading: true,
+                                                    showCommentInput: true,
+                                                },
+                                            }, items: feedItems, onAddComment: handleAddComment, onAddReply: handleAddReply, onToggleReaction: handleToggleReaction }) }, actionRefreshKey), modalElement] }) }) }), _jsx(MetadataPanel, { open: showDebug, sections: [{ title: 'View Schema', data: detailSchema }] })] }), _jsx(ActionConfirmDialog, { state: confirmState, onOpenChange: (open) => {
                     if (!open)
                         setConfirmState(s => ({ ...s, open: false }));
                 } }), _jsx(ActionParamDialog, { state: paramState, onOpenChange: (open) => {
                     if (!open)
                         setParamState(s => ({ ...s, open: false }));
-                } })] }));
+                } }), _jsx(ActionResultDialog, { state: resultDialogState, onAcknowledge: () => {
+                    resultDialogState.resolve?.();
+                    setResultDialogState({ open: false });
+                } }), _jsx(FlowRunner, { state: screenFlow, authFetch: authFetch, baseUrl: import.meta.env.VITE_SERVER_URL || '', dataSource: dataSource, objects: objects, onClose: () => setScreenFlow(null), onComplete: () => { setScreenFlow(null); setActionRefreshKey(k => k + 1); } })] }));
 }