@@ -46,7 +46,11 @@ import { RECORD_PAGE_ATTACHMENT_ROWS, recordAttachmentsCountField } from './reco
  *
  * Storage model: one `sys_file` row per uploaded blob (three-step
  * presigned upload via @object-ui/data-objectstack's ObjectStack adapter), one
- * `sys_attachment` join row linking it to `(parent_object, parent_id)`.
+ * `sys_attachment` join row linking it to `(parent_object, parent_id)`. The
+ * join row is written by the upload's own completion (`attachTo`), as the
+ * signed-in user: the server's attach verb, never a `sys_attachment` create
+ * through the generic data door, which a member who may attach files but not
+ * read `sys_file` is refused (`reference_not_found` on `file_id`).
  * Downloads fetch a short-lived signed URL from `/storage/files/:fileId/url`
  * with the console's Bearer token (the endpoint requires an authenticated
  * session for attachments-scope files, objectstack-ai/objectstack#2970), then open it.
@@ -65,9 +69,9 @@ interface AttachmentRow {
 export interface RecordAttachmentsPanelProps {
   objectName: string;
   recordId: string;
-  /** ObjectUI DataSource (sys_attachment CRUD goes through the generic data path). */
+  /** ObjectUI DataSource (the list read and the delete go through the generic data path; the attach does not). */
   dataSource: any;
-  /** Current user id, stamped on `uploaded_by`. */
+  /** Current user id. The server stamps `uploaded_by` from the session; the panel no longer sends it. */
   currentUserId?: string | null;
   className?: string;
 }
@@ -175,7 +179,6 @@ export const RecordAttachmentsPanel: React.FC<RecordAttachmentsPanelProps> = ({
   objectName,
   recordId,
   dataSource,
-  currentUserId,
   className,
 }) => {
   const { t } = useObjectTranslation();
@@ -216,10 +219,10 @@ export const RecordAttachmentsPanel: React.FC<RecordAttachmentsPanelProps> = ({
    * and a delete go through the storage route, not `sys_attachment`'s generic
    * data door, so that door's operation set says nothing about them.
    *
-   * Upload needs `create`. Without it the three-step presigned flow below
-   * commits a `sys_file` and only the final `sys_attachment` insert is
-   * refused: the user meets the error after the bytes are stored, and the file
-   * stays committed with nothing attached to it.
+   * Upload needs `create`. Without it the attach at the end of the upload
+   * below is refused after the bytes are stored (the server leaves the file
+   * pending, and its retention reclaims it); hiding Upload spares the user
+   * that round trip.
    *
    * Delete needs `delete`, and being the uploader does not change that. The
    * server asks the object grant first (plugin-security's CRUD check wraps the
@@ -252,9 +255,17 @@ export const RecordAttachmentsPanel: React.FC<RecordAttachmentsPanelProps> = ({
   // upload adapter and the download-URL fetch — the storage routes require a
   // session and there is no cookie for `credentials: 'include'` to carry.
   const authFetch = React.useMemo(() => createAuthenticatedFetch(), []);
+  // Every upload from this panel is attached to this record by the call that
+  // completes it (`attachTo`): the server's attach verb, run as the user.
   const adapter = React.useMemo(
-    () => createObjectStackUploadAdapter({ baseUrl, scope: 'attachments', fetchImpl: authFetch }),
-    [baseUrl, authFetch],
+    () =>
+      createObjectStackUploadAdapter({
+        baseUrl,
+        scope: 'attachments',
+        fetchImpl: authFetch,
+        ...(objectName && recordId ? { attachTo: { parentObject: objectName, parentId: recordId } } : {}),
+      }),
+    [baseUrl, authFetch, objectName, recordId],
   );
 
   /** Map the server's fail-closed 40x codes (objectstack-ai/objectstack#2755, objectstack-ai/objectstack#2970) to friendly copy. */
@@ -390,27 +401,18 @@ export const RecordAttachmentsPanel: React.FC<RecordAttachmentsPanelProps> = ({
 
   const handleFiles = React.useCallback(
     async (files: FileList | null) => {
-      if (!files || files.length === 0 || !dataSource) return;
+      if (!files || files.length === 0 || !dataSource || !objectName || !recordId) return;
       setUploading(true);
       setError(null);
       try {
         for (const file of Array.from(files)) {
-          // 1) blob → sys_file via the canonical presigned three-step flow
+          // blob → sys_file → sys_attachment: the presigned three-step flow,
+          // whose completion attaches the file to this record as the user
+          // (the server checks the create grant, edit access to the record,
+          // `enable.files`, and that the file is the user's own upload).
           const uploaded = await adapter.upload(file);
-          const fileId = (uploaded.meta as any)?.fileId as string | undefined;
-          if (!fileId) throw new Error('Upload did not return a fileId');
-          // 2) join row → sys_attachment (server enforces enable.files)
-          await dataSource.create('sys_attachment', {
-            parent_object: objectName,
-            parent_id: recordId,
-            file_id: fileId,
-            file_name: uploaded.name ?? file.name,
-            mime_type: uploaded.mimeType ?? file.type,
-            size: uploaded.size ?? file.size,
-            // Back-compat with pre-objectstack-ai/objectstack#2755 servers; a current server stamps
-            // `uploaded_by` from the session and ignores this value.
-            ...(currentUserId ? { uploaded_by: currentUserId } : {}),
-          });
+          const attachmentId = (uploaded.meta as any)?.attachmentId as string | undefined;
+          if (!attachmentId) throw new Error('The server completed the upload but did not attach it to this record');
         }
         await refresh();
       } catch (err: any) {
@@ -420,7 +422,7 @@ export const RecordAttachmentsPanel: React.FC<RecordAttachmentsPanelProps> = ({
         if (inputRef.current) inputRef.current.value = '';
       }
     },
-    [adapter, dataSource, objectName, recordId, currentUserId, refresh],
+    [adapter, dataSource, objectName, recordId, refresh],
   );
 
   /**
 
@@ -36,12 +36,17 @@ import { render, screen, waitFor, within, act } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { MePermissionsProvider, type MePermissionsAuthenticatedResponse } from '@object-ui/permissions';
 
-/** The fake presigned adapter: `upload` resolving means a `sys_file` was committed. */
+/** The fake presigned adapter: `upload` resolving means the file was committed and attached. */
 const adapterUpload = vi.fn();
+/** The options the panel built its adapter with — `attachTo` names the record. */
+const adapterOptions = vi.fn();
 
 vi.mock('@object-ui/data-objectstack', async (importOriginal) => ({
   ...(await importOriginal<Record<string, unknown>>()),
-  createObjectStackUploadAdapter: () => ({ upload: adapterUpload }),
+  createObjectStackUploadAdapter: (opts: unknown) => {
+    adapterOptions(opts);
+    return { upload: adapterUpload };
+  },
 }));
 
 import { RecordAttachmentsPanel } from '../RecordAttachmentsPanel';
@@ -174,20 +179,15 @@ describe('RecordAttachmentsPanel — write affordances follow the sys_attachment
   });
 
   it('CONTROL — with Upload shown and the server refusing the attach, the refusal message still appears', async () => {
-    adapterUpload.mockResolvedValue({
-      name: 'quote.pdf',
-      mimeType: 'application/pdf',
-      size: 10,
-      meta: { fileId: 'f-new' },
-    });
-    const dataSource = makeDataSource({
-      create: vi.fn(async () => {
-        throw Object.assign(new Error("[Security] Access denied: operation 'insert' on sys_attachment"), {
-          httpStatus: 403,
-          code: 'PERMISSION_DENIED',
-        });
+    // The attach is the upload's own completion (`attachTo`), so the server's
+    // refusal is the upload's.
+    adapterUpload.mockRejectedValue(
+      Object.assign(new Error('Upload completion failed (403): {"success":false,"error":{"code":"PERMISSION_DENIED"}}'), {
+        status: 403,
+        code: 'PERMISSION_DENIED',
       }),
-    });
+    );
+    const dataSource = makeDataSource();
     const { container } = renderWithGrant({ allowCreate: true }, dataSource);
     await rowsLoaded();
     expect(screen.getByRole('button', { name: 'Upload' })).toBeInTheDocument();
@@ -200,10 +200,11 @@ describe('RecordAttachmentsPanel — write affordances follow the sys_attachment
       expect(screen.getByRole('alert')).toHaveTextContent("You don't have permission to do that."),
     );
     expect(adapterUpload).toHaveBeenCalledTimes(1);
-    expect(dataSource.create).toHaveBeenCalledWith(
-      'sys_attachment',
-      expect.objectContaining({ parent_object: 'att_case', parent_id: 'r1', file_id: 'f-new' }),
+    expect(adapterOptions).toHaveBeenLastCalledWith(
+      expect.objectContaining({ scope: 'attachments', attachTo: { parentObject: 'att_case', parentId: 'r1' } }),
     );
+    // No `sys_attachment` create through the generic data door.
+    expect(dataSource.create).not.toHaveBeenCalled();
   });
 
   it('no flash while permissions load: a read-only answer never shows Upload, not even before it arrives', async () => {
 
@@ -846,3 +846,81 @@ describe('RecordAttachmentsPanel — mobile shell openFile', () => {
     expect(host.openFile).not.toHaveBeenCalled();
   });
 });
+
+/**
+ * The upload attaches through the server's attach verb: the presigned upload's
+ * own completion carries `attachTo` (`POST /api/v1/storage/upload/complete`),
+ * and the server commits the file and writes its `sys_attachment` row as the
+ * signed-in user. The panel never creates `sys_attachment` through the generic
+ * data door, which refuses a member who may attach but cannot read `sys_file`.
+ * Driven through the REAL ObjectStack upload adapter over a stubbed `fetch`.
+ */
+describe('RecordAttachmentsPanel — upload attaches through the upload’s own completion', () => {
+  const ok = (data: unknown) =>
+    new Response(JSON.stringify({ success: true, data }), { status: 200, headers: { 'content-type': 'application/json' } });
+
+  function stubStorage(complete: () => Response) {
+    const calls: Array<{ url: string; method: string; body: unknown }> = [];
+    const spy = vi.spyOn(globalThis, 'fetch').mockImplementation(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+      const method = init?.method ?? 'GET';
+      const body = typeof init?.body === 'string' ? JSON.parse(init.body) : init?.body;
+      calls.push({ url, method, body });
+      if (url.endsWith('/api/v1/storage/upload/presigned')) {
+        return ok({ uploadUrl: '/api/v1/storage/_local/raw/tok', method: 'PUT', fileId: 'f-new', headers: {} });
+      }
+      if (url.endsWith('/api/v1/storage/_local/raw/tok')) return ok({ key: 'attachments/f-new.pdf' });
+      if (url.endsWith('/api/v1/storage/upload/complete')) return complete();
+      throw new Error(`unexpected fetch ${method} ${url}`);
+    });
+    return { spy, calls };
+  }
+
+  async function uploadOne() {
+    const dataSource = makeDataSource();
+    const { container } = render(
+      <RecordAttachmentsPanel objectName="att_case" recordId="r1" dataSource={dataSource} currentUserId="me" />,
+    );
+    await waitFor(() => expect(screen.getByText('report.pdf')).toBeInTheDocument());
+    const input = container.querySelector('input[type="file"]') as HTMLInputElement;
+    await userEvent.setup().upload(input, new File(['%PDF'], 'quote.pdf', { type: 'application/pdf' }));
+    return dataSource;
+  }
+
+  afterEach(() => vi.restoreAllMocks());
+
+  it('completes the upload with attachTo naming this record, and creates no sys_attachment through the data door', async () => {
+    const { calls } = stubStorage(() => ok({ fileId: 'f-new', name: 'quote.pdf', attachmentId: 'a-new' }));
+    const dataSource = await uploadOne();
+    await waitFor(() => expect(dataSource.find).toHaveBeenCalledTimes(2)); // the list re-read after the attach
+    const complete = calls.find((c) => c.url.endsWith('/upload/complete'));
+    expect(complete).toMatchObject({
+      method: 'POST',
+      body: { fileId: 'f-new', attachTo: { parentObject: 'att_case', parentId: 'r1' } },
+    });
+    expect(calls.find((c) => c.url.endsWith('/upload/presigned'))?.body).toMatchObject({ scope: 'attachments' });
+    expect(dataSource.create).not.toHaveBeenCalled();
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+  });
+
+  it('maps the attach verb’s ATTACHMENT_PARENT_ACCESS refusal to the friendly copy', async () => {
+    stubStorage(
+      () =>
+        new Response(
+          JSON.stringify({ success: false, error: { code: 'ATTACHMENT_PARENT_ACCESS', message: 'Cannot attach to att_case/r1' } }),
+          { status: 403, headers: { 'content-type': 'application/json' } },
+        ),
+    );
+    const dataSource = await uploadOne();
+    await waitFor(() =>
+      expect(screen.getByRole('alert')).toHaveTextContent("You don't have access to attach files to this record."),
+    );
+    expect(dataSource.create).not.toHaveBeenCalled();
+  });
+
+  it('a completion that attached nothing is an error, never a silent success', async () => {
+    stubStorage(() => ok({ fileId: 'f-new', name: 'quote.pdf' }));
+    await uploadOne();
+    await waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent('did not attach it to this record'));
+  });
+});
@@ -45,6 +45,18 @@ export interface ObjectStackUploadAdapterOptions {
    * declares (objectui#12055).
    */
   scope?: API.UploadScope;
+  /**
+   * Attach every upload from this adapter to this record, in the call that
+   * completes it: the completion request carries `attachTo`, and the server
+   * commits the file and writes its `sys_attachment` row as one unit, as the
+   * signed-in caller (the record attachments surface's attach verb). The
+   * result's `meta.attachmentId` names the new attachment. The server attaches
+   * only the caller's own pending upload in the `attachments` scope, so set
+   * `scope: 'attachments'` with it. A refused attach fails the upload with the
+   * server's refusal and leaves the file pending, never committed and
+   * unattached.
+   */
+  attachTo?: { parentObject: string; parentId: string };
   /** Override `fetch` (tests, ServiceWorker queues). */
   fetchImpl?: typeof fetch;
   /**
@@ -64,7 +76,8 @@ export interface ObjectStackUploadAdapterOptions {
  *   1. POST `/upload/presigned`   → `{ uploadUrl, fileId, downloadUrl }`
  *   2. PUT  `uploadUrl`           → uploads the raw bytes (HMAC token)
  *   3. POST `/upload/complete`    → marks the file ready and registers
- *                                   the `sys_file` record
+ *                                   the `sys_file` record — and, with
+ *                                   `attachTo`, attaches it to that record
  *
  * Falls back to a canonical (non-signed) download URL so the returned
  * `UploadResult.url` is stable across signed-URL expiry — components
@@ -136,14 +149,27 @@ export function createObjectStackUploadAdapter(
         credentials,
         headers: { 'Content-Type': 'application/json' },
         signal: options.signal,
-        body: JSON.stringify({ fileId }),
+        body: JSON.stringify(opts.attachTo ? { fileId, attachTo: opts.attachTo } : { fileId }),
       });
       if (!completeRes.ok) {
         const text = await completeRes.text().catch(() => '');
-        throw new Error(
-          `Upload completion failed (${completeRes.status}): ${text || completeRes.statusText}`,
+        // The server's refusal code and status ride on the error, so a caller
+        // maps a refused attach (`ATTACHMENT_PARENT_ACCESS`, `FILES_DISABLED`,
+        // `PERMISSION_DENIED`…) without parsing the message.
+        let code: string | undefined;
+        try {
+          const parsed = JSON.parse(text);
+          if (typeof parsed?.error?.code === 'string') code = parsed.error.code;
+        } catch {
+          // Not the declared envelope — the message keeps the raw text.
+        }
+        throw Object.assign(
+          new Error(`Upload completion failed (${completeRes.status}): ${text || completeRes.statusText}`),
+          { status: completeRes.status, ...(code ? { code } : {}) },
         );
       }
+      const completeBody = opts.attachTo ? await completeRes.json().catch(() => null) : null;
+      const attachmentId = (completeBody?.data ?? completeBody)?.attachmentId as string | undefined;
 
       // Use the canonical (stable) download endpoint as the field value
       // so a saved record keeps working past signed-URL expiry. This
@@ -156,7 +182,7 @@ export function createObjectStackUploadAdapter(
         name,
         size: file.size,
         mimeType,
-        meta: { fileId, scope: opts.scope },
+        meta: { fileId, scope: opts.scope, ...(attachmentId ? { attachmentId } : {}) },
       };
     },
   };