@@ -32,6 +32,7 @@
     "@objectstack/formula": "workspace:*",
     "@objectstack/spec": "workspace:*",
     "@objectstack/types": "workspace:*",
+    "unpdf": "1.9.1",
     "zod": "^4.6.6"
   },
   "devDependencies": {
 
@@ -92,6 +92,8 @@ import {
   metadataPartialListingSentence,
   type DiagnosedObjectListing,
 } from './metadata-completeness.js';
+// [#30892] The file seam and what `read_file` renders from it.
+import { READ_FILE_MAX_BYTES, renderReadFile, type McpFileBridge } from './file-content.js';
 
 export interface McpObjectSummary {
   name: string;
@@ -824,10 +826,13 @@ const RECORD_ID_ALIASES = { id: 'recordId', record_id: 'recordId' } as const;
  */
 export function wireBridgeTools(
   server: McpServer,
-  bridge: McpDataBridge & Partial<McpActionBridge> & Partial<McpFederationBridge>,
+  bridge: McpDataBridge & Partial<McpActionBridge> & Partial<McpFederationBridge> & McpFileBridge,
   options: RegisterObjectToolsOptions & RegisterActionToolsOptions = {},
 ): string[] {
   const registered = registerObjectTools(server, bridge, options);
+  // [#30892] `read_file` / `create_upload_link`, each only where the bridge
+  // implements its member.
+  registered.push(...registerFileTools(server, bridge, options));
   if (typeof bridge.listActions === 'function' && typeof bridge.runAction === 'function') {
     registered.push(...registerActionTools(server, bridge as McpActionBridge, options));
   }
@@ -1818,6 +1823,169 @@ export function registerActionTools(
   return registered;
 }
 
+/**
+ * [#30892] Register the file pair over {@link McpFileBridge}: `read_file`
+ * (with `data:read`) reads a file a record carries, and `create_upload_link`
+ * (with `data:write`) mints a single-use link through which the user uploads
+ * a file onto a record. Each registers only where the bridge implements its
+ * member, so a host that cannot reach a record's files serves neither.
+ *
+ * Neither tool judges access itself. The bridge reads the record as the
+ * caller first (the `get_record` door), so a record the caller cannot read is
+ * refused here with the code `get_record` answers; the storage service then
+ * asks the download door's own verdict for the file, and the attach rule's
+ * for a link. `sys_*` objects are refused as every object tool refuses them.
+ */
+export function registerFileTools(
+  server: McpServer,
+  bridge: McpFileBridge,
+  options: RegisterObjectToolsOptions = {},
+): string[] {
+  const registered: string[] = [];
+  const note = (name: string): string => {
+    registered.push(name);
+    return name;
+  };
+  const allowSystem = options.allowSystemObjects === true;
+  const scopes = options.grantedScopes;
+  const canRead = !scopes || scopes.includes(MCP_OAUTH_SCOPE_DATA_READ);
+  const canWrite = !scopes || scopes.includes(MCP_OAUTH_SCOPE_DATA_WRITE);
+  const guard = (objectName: string): string | undefined => {
+    if (!objectName || typeof objectName !== 'string') return 'objectName is required';
+    if (!allowSystem && isSystemObject(objectName)) {
+      return `Object "${objectName}" is a system object and is not exposed via MCP`;
+    }
+    return undefined;
+  };
+
+  if (canRead && typeof bridge.readRecordFile === 'function') {
+    const readFn = bridge.readRecordFile.bind(bridge);
+    const listFn = typeof bridge.listRecordFiles === 'function' ? bridge.listRecordFiles.bind(bridge) : undefined;
+    server.registerTool(
+      note('read_file'),
+      {
+        description:
+          'Read a file a record carries: one held by a file field (field, plus fileId when the field holds several) ' +
+          'or one of its attachments (attachmentId). Answers the file\'s facts (name, type, size in bytes, the ' +
+          `byte cap read_file reads, ${READ_FILE_MAX_BYTES}) with a short-lived download link, then its content: the ` +
+          'text of a text file, a PDF or a Word (.docx) document, or the image itself. A larger file answers its ' +
+          'facts and the link only. ' +
+          (listFn
+            ? 'Name neither field nor attachmentId to list the files on the record you can read, with their ids. '
+            : '') +
+          'You can read a file only where you can read its record: a record you cannot read answers as not found.',
+        inputSchema: strictToolInput(
+          {
+            surface: 'this read_file call',
+            aliases: {
+              ...OBJECT_NAME_ALIASES,
+              ...RECORD_ID_ALIASES,
+              fieldName: 'field',
+              field_name: 'field',
+              file_id: 'fileId',
+              attachment_id: 'attachmentId',
+              attachment: 'attachmentId',
+            },
+          },
+          {
+            objectName: z.string().describe('The object/table name'),
+            recordId: z.string().describe('The record id'),
+            field: z.string().optional().describe('A file or image field of the record'),
+            fileId: z
+              .string()
+              .optional()
+              .describe('Which file, when the field holds several (a multi-file field); with field only'),
+            attachmentId: z.string().optional().describe('One of the record\'s attachments, by its id'),
+          },
+        ),
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+      },
+      async ({ objectName, recordId, field, fileId, attachmentId }) => {
+        const bad = guard(objectName);
+        if (bad) return errorResult(bad);
+        if (field !== undefined && attachmentId !== undefined) {
+          return errorResult('Name one file: either field (with fileId for a multi-file field) or attachmentId, not both.');
+        }
+        if (fileId !== undefined && field === undefined) {
+          return errorResult('fileId names a file within a field: send field with it.');
+        }
+        try {
+          if (field === undefined && attachmentId === undefined) {
+            if (!listFn) return errorResult('Name the file to read: field (a file field of the record) or attachmentId.');
+            return textResult({ files: await listFn(objectName, recordId) });
+          }
+          const target = attachmentId !== undefined ? { attachmentId } : { field: field as string, ...(fileId !== undefined ? { fileId } : {}) };
+          const file = await readFn(objectName, recordId, target, { maxBytes: READ_FILE_MAX_BYTES });
+          return { content: await renderReadFile(file) };
+        } catch (err) {
+          return errorResultWithCode(err);
+        }
+      },
+    );
+  }
+
+  if (canWrite && typeof bridge.createUploadLink === 'function') {
+    const linkFn = bridge.createUploadLink.bind(bridge);
+    server.registerTool(
+      note('create_upload_link'),
+      {
+        description:
+          'Create a link through which the user uploads one file onto a record: into a file field (field) or ' +
+          'as an attachment (attachments: true). Give the link to the user to open; it works once, for this ' +
+          'record and field only, and expires (see expiresAt). The upload is stored as the user, so they must be ' +
+          'able to edit the record (and the field).',
+        inputSchema: strictToolInput(
+          {
+            surface: 'this create_upload_link call',
+            aliases: {
+              ...OBJECT_NAME_ALIASES,
+              ...RECORD_ID_ALIASES,
+              fieldName: 'field',
+              field_name: 'field',
+              attachment: 'attachments',
+            },
+          },
+          {
+            objectName: z.string().describe('The object/table name'),
+            recordId: z.string().describe('The record id'),
+            field: z.string().optional().describe('A file or image field of the record the upload fills'),
+            attachments: z
+              .literal(true)
+              .optional()
+              .describe('true to attach the upload to the record instead of filling a field'),
+          },
+        ),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+      },
+      async ({ objectName, recordId, field, attachments }) => {
+        const bad = guard(objectName);
+        if (bad) return errorResult(bad);
+        if ((field === undefined) === (attachments === undefined)) {
+          return errorResult('Say where the upload lands: either field (a file field of the record) or attachments: true.');
+        }
+        try {
+          const target = field !== undefined ? { field } : { attachments: true as const };
+          const link = await linkFn(objectName, recordId, target);
+          return textResult({
+            url: link.url,
+            expiresAt: link.expiresAt,
+            singleUse: true,
+            objectName,
+            recordId,
+            ...(field !== undefined ? { field } : { attachments: true }),
+            instructions:
+              'Give this link to the user to open in a browser and pick the file. It works once, until expiresAt.',
+          });
+        } catch (err) {
+          return errorResultWithCode(err);
+        }
+      },
+    );
+  }
+
+  return registered;
+}
+
 function messageOf(err: unknown): string {
   if (err instanceof Error) return err.message;
   if (err && typeof err === 'object' && 'message' in err) return String((err as any).message);
 
@@ -11,6 +11,7 @@ import type { AIToolDefinition } from '@objectstack/spec/contracts';
 
 import { MCPServerRuntime } from './mcp-server-runtime.js';
 import type { McpDataBridge, McpActionBridge } from './mcp-http-tools.js';
+import type { McpFileBridge } from './file-content.js';
 import type { McpAuthoringToolRegistry, ToolExecutionResult } from './types.js';
 import { renderSkillMarkdown } from './skill-md.js';
 
@@ -34,8 +35,8 @@ import { renderSkillMarkdown } from './skill-md.js';
  * tool to `mcp-http-tools.ts` without teaching the skill turns this red.
  */
 
-/** Minimal full-surface bridge: object + action methods present, all stubbed. */
-function makeFullBridge(): McpDataBridge & McpActionBridge {
+/** Minimal full-surface bridge: object + action + file methods present, all stubbed. */
+function makeFullBridge(): McpDataBridge & McpActionBridge & McpFileBridge {
   return {
     async listObjects() {
       return [];
@@ -69,6 +70,18 @@ function makeFullBridge(): McpDataBridge & McpActionBridge {
     async resumeRun() {
       return {};
     },
+    // [#30892] The file pair's members, so `read_file` / `create_upload_link`
+    // are on the surface this guard reads: a host with the storage plugin
+    // carries them, and its skill is rendered with `fileTools: true`.
+    async listRecordFiles() {
+      return [];
+    },
+    async readRecordFile() {
+      return { fileId: 'f', name: 'f', mimeType: null, size: null, maxBytes: 0, download: null };
+    },
+    async createUploadLink() {
+      return { url: 'https://x.test/u', expiresAt: '2026-01-01T00:00:00.000Z' };
+    },
   };
 }
 
@@ -132,7 +145,7 @@ describe('SKILL.md ↔ native tool surface drift guard', () => {
     // Sanity: the harness must see the full surface, or the guard guards nothing.
     expect(registered.length).toBeGreaterThanOrEqual(9);
 
-    const md = renderSkillMarkdown();
+    const md = renderSkillMarkdown({ fileTools: true });
     const undocumented = registered.filter((name) => !md.includes(name));
     expect(undocumented, `tools registered but missing from SKILL.md — update packages/mcp/src/skill-md.ts: ${undocumented.join(', ')}`).toEqual([]);
   });
@@ -145,7 +158,7 @@ describe('SKILL.md ↔ native tool surface drift guard', () => {
     for (const t of AUTHORING_TOOLS) expect(registered).toContain(t.name);
 
     // The skill rendered for the SAME grant and the SAME registry names every one of them …
-    const md = renderSkillMarkdown({ grantedScopes: EVERY_SCOPE, authoringTools: registry.getAll() });
+    const md = renderSkillMarkdown({ grantedScopes: EVERY_SCOPE, authoringTools: registry.getAll(), fileTools: true });
     const undocumented = registered.filter((name) => !md.includes(name));
     expect(undocumented, `tools registered but missing from the authoring SKILL.md: ${undocumented.join(', ')}`).toEqual([]);
 
 
@@ -31,7 +31,7 @@
  */
 
 import type { AIToolDefinition } from '@objectstack/spec/contracts';
-import { MCP_OAUTH_SCOPE_DATA_READ, MCP_OAUTH_SCOPE_METADATA_WRITE } from '@objectstack/spec/ai';
+import { MCP_OAUTH_SCOPE_DATA_READ, MCP_OAUTH_SCOPE_DATA_WRITE, MCP_OAUTH_SCOPE_METADATA_WRITE } from '@objectstack/spec/ai';
 import { grantsAuthoringTools } from './mcp-http-tools.js';
 
 /** Skill identity (mirrors the `SKILL.md` YAML frontmatter). */
@@ -100,6 +100,15 @@ export interface RenderSkillOptions {
    * renderer cannot see the bridge, so the host says so.
    */
   federationTools?: boolean;
+  /**
+   * [#30892] Whether the host's bridge carries the file pair (`read_file` /
+   * `create_upload_link`, `registerFileTools`). Each entry renders only when
+   * this is true AND {@link grantedScopes} admit its family (`read_file`:
+   * `data:read`; `create_upload_link`: `data:write`), so the skill names them
+   * exactly where `tools/list` lists them. Default false: the renderer cannot
+   * see the bridge, so the host says so.
+   */
+  fileTools?: boolean;
 }
 
 const URL_PLACEHOLDER = '<YOUR_ENV_MCP_URL>'; // e.g. https://<env>.objectos.app/api/v1/mcp
@@ -165,6 +174,34 @@ const FEDERATION_TOOL_LINES = `- **list_remote_tables({ datasource, schema? })**
   \`review\` names lossy columns and left-out navigations.
 `;
 
+/** [#30892] `read_file`'s entry, rendered where `registerFileTools` registers it (`data:read`). */
+const READ_FILE_TOOL_LINES = `- **read_file({ objectName, recordId, field?, fileId?, attachmentId? })** —
+  read a file a record carries: one in a file field (\`field\`, plus \`fileId\`
+  for a multi-file field) or one attachment (\`attachmentId\`). Answers the
+  file's name, type and size, the byte cap it reads, and a short-lived download
+  link, then the text of a text file, PDF or Word document, or the image
+  itself. Send neither \`field\` nor \`attachmentId\` to list the record's
+  files with their ids. A record you cannot read answers as not found.
+`;
+
+/** [#30892] `create_upload_link`'s entry, rendered where `registerFileTools` registers it (`data:write`). */
+const UPLOAD_LINK_TOOL_LINES = `- **create_upload_link({ objectName, recordId, field? | attachments: true })** —
+  a link through which the user uploads one file onto a record: into a file
+  field, or as an attachment. Give the link to the user; it works once, for
+  that record and field only, and expires at \`expiresAt\`. The upload is
+  stored as the user, so they must be able to edit the record.
+`;
+
+/** The file pair's entries for a host whose bridge carries them, each for the grant that registers it. */
+function renderFileToolLines(options: RenderSkillOptions): string {
+  if (options.fileTools !== true) return '';
+  const scopes = options.grantedScopes;
+  // Mirrors the gates in `registerFileTools` (`!scopes || scopes.includes(…)`).
+  const read = !scopes || scopes.includes(MCP_OAUTH_SCOPE_DATA_READ);
+  const write = !scopes || scopes.includes(MCP_OAUTH_SCOPE_DATA_WRITE);
+  return (read ? READ_FILE_TOOL_LINES : '') + (write ? UPLOAD_LINK_TOOL_LINES : '');
+}
+
 /**
  * Render the full `SKILL.md` (YAML frontmatter + body). Pass the env's MCP URL
  * to produce a ready-to-install skill; the body is otherwise generic.
@@ -308,7 +345,7 @@ create/update payload.
   screen, which you fill with another \`resume_run\`. Only the user whose call
   started the run can resume it, under the same gates as \`run_action\`
   (including \`confirm: true\` for an action flagged \`requiresConfirmation\`).
-${options.federationTools === true && grantsAuthoringTools(options.grantedScopes) ? FEDERATION_TOOL_LINES : ''}${authoringTools ? renderAuthoringSection(authoringTools, describeObjectRegistered) : ''}
+${renderFileToolLines(options)}${options.federationTools === true && grantsAuthoringTools(options.grantedScopes) ? FEDERATION_TOOL_LINES : ''}${authoringTools ? renderAuthoringSection(authoringTools, describeObjectRegistered) : ''}
 ## Conventions & gotchas
 
 - **Permissions/RLS apply to every call.** Fewer rows than expected, or a