@@ -0,0 +1,19 @@
+---
+'@objectstack/mcp': patch
+---
+
+fix(mcp): the record data tools and the record resource answer a driver's own error code (`SQLITE_BUSY`) as `/api/v1/data` does, a sanitised server fault, never the driver's text
+
+Clause-②: no
+Metadata-protocol: none
+
+A database driver's error carries its own code on `.code` (`SQLITE_BUSY`, `ECONNRESET`, Postgres `40P01`) and no HTTP status. `query_records`, `aggregate_records`, `get_record`, `create_record`, `update_record`, `delete_record`, `delete_records`' selection read and the `objectstack://objects/{name}/records/{id}` resource read any thrown `code` as a coded refusal, so an agent got `{ "code": "SQLITE_BUSY", "message": "SQLITE_BUSY: database is locked" }` with no status. `/api/v1/data` answers the same throw `500 DATABASE_ERROR` `Internal data error` and logs the driver's text.
+
+These faces now answer such a throw with the `/data` door's answer, read through that door's own classifier (`mapDataError`, `@objectstack/types`):
+
+- `SQLITE_BUSY`: `{ "code": "DATABASE_ERROR", "message": "Internal data error", "status": 500 }` on the tools, `{ "error": "Internal data error", "code": "DATABASE_ERROR", "status": 500 }` on the resource;
+- a driver code whose text names no store (`ECONNRESET`): `500 INTERNAL_ERROR` `Internal server error`.
+
+The driver's code and text are logged once on the server as a `[5xx]` line instead of being sent.
+
+The rule is the door's: a thrown code that declared no HTTP status, and that the door answers as a server fault, is a fault, not a refusal. So a code thrown with no status that the door does not recognise as a refusal (for example `RECORD_LOCKED` with no `status`) now answers the door's `500 INTERNAL_ERROR` here too; declare the status you mean to keep the code. A code thrown with its status (`RECORD_LOCKED` / 409, `SERVICE_UNAVAILABLE` / 503), a code the door answers as a refusal without one (`PERMISSION_DENIED`), and a sandboxed hook's coded refusal are answered as before. `run_action`, `resume_run` and the metadata tools are not changed.
@@ -658,6 +658,38 @@ describe('the record resource: a coded refusal adds its code beside the unchange
       expect(log).not.toHaveBeenCalled();
     });
   });
+  /**
+   * [#31273] A driver's own string code answers the door's server fault here
+   * too, through the same predicate the record data tools ask (their block,
+   * below, says why). The #31270 hand-off's `SQLITE_BUSY` row.
+   */
+  describe('a driver\'s own string code answers the /data door\'s server fault (#31273)', () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('SQLITE_BUSY: 500 DATABASE_ERROR \'Internal data error\', the driver text withheld and logged once', async () => {
+      const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const thrown = sqliteBusy();
+      const text = await readRefused(thrown);
+      expect(text).toBe(JSON.stringify({ error: 'Internal data error', code: 'DATABASE_ERROR', status: 500 }));
+      const door = mapDataError(thrown, 'task');
+      expect(JSON.parse(text)).toEqual({ error: door.body.error, code: door.body.code, status: door.status });
+      expect(log).toHaveBeenCalledTimes(1);
+      const line = String(log.mock.calls[0]![0]);
+      expect(line).toMatch(/^\[5xx\] 500 resources\/read objectstack:\/\/objects\/task\/records\/t1 — /);
+      expect(line).toContain('SQLITE_BUSY: database is locked');
+    });
+
+    it('CONTROL: a declared 5xx code and a code the door refuses with no status keep their coded answers, unlogged', async () => {
+      const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(JSON.parse(await readRefused(Object.assign(new Error('The ledger is closing.'), { code: 'SERVICE_UNAVAILABLE', status: 503 }))))
+        .toEqual({ error: 'The ledger is closing.', code: 'SERVICE_UNAVAILABLE', status: 503 });
+      expect(JSON.parse(await readRefused(Object.assign(new Error('Field read denied: salary'), { code: 'PERMISSION_DENIED' }))))
+        .toEqual({ error: 'Field read denied: salary', code: 'PERMISSION_DENIED' });
+      expect(log).not.toHaveBeenCalled();
+    });
+  });
 });
 
 /**
@@ -836,3 +868,124 @@ describe('the metadata tools and list_actions: a fault answers what the /meta do
     }
   });
 });
+
+/**
+ * [#31273] A driver's own string code (`SQLITE_BUSY`, `ECONNRESET`, `40P01`)
+ * rides `.code` with no HTTP status. The `/api/v1/data` door answers it as a
+ * server fault (`mapDataError`, `@objectstack/types`): `500 DATABASE_ERROR`
+ * `Internal data error` when its text names the store, the driver text and
+ * errno withheld and logged once. The record data tools read the coded path
+ * first, so an agent got `{ code: 'SQLITE_BUSY', message: 'SQLITE_BUSY:
+ * database is locked' }` with no status.
+ *
+ * A coded throw is now a coded refusal on these faces unless the door answers
+ * it as a server fault whose status the producer did not declare
+ * (`serverFaultProvenance` `'undeclared'`, `@objectstack/types`, the ruling of
+ * 2026-08-27 on #12509: the discriminator is the status channel, never the
+ * code's spelling). Then the face answers the door's fault.
+ *
+ * Only the record data tools, `delete_records`' selection read and the record
+ * resource (its rows are below). `run_action` / `resume_run` and the metadata
+ * tools answer a driver code through their own doors' readers (#31271,
+ * #31272), so this block does not pin them.
+ */
+function sqliteBusy(): Error {
+  return Object.assign(new Error('SQLITE_BUSY: database is locked'), { code: 'SQLITE_BUSY' });
+}
+
+describe('the record data tools: a driver\'s own string code is the /data door\'s server fault, not a coded refusal (#31273)', () => {
+  const FACES = SITES.filter((s) => s.dataDoor || s.tool === 'delete_records');
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  /** The tool's answer, parsed, after asserting it is a tool error. */
+  async function errorOf(site: Site, thrown: unknown): Promise<{ text: string; error: Record<string, unknown> }> {
+    const result = await callTool(site, thrown);
+    expect(result.isError).toBe(true);
+    expect(result.content).toHaveLength(1);
+    const text = String(result.content[0].text);
+    return { text, error: JSON.parse(text).error };
+  }
+
+  /** The `/data` door's answer to the same throw, in the tool's envelope spelling. */
+  function doorAnswer(thrown: unknown): Record<string, unknown> {
+    const door = mapDataError(thrown, 'task');
+    return { code: door.body.code, message: door.body.error, status: door.status };
+  }
+
+  it('the faces are the six record data tools and delete_records\' selection read', () => {
+    expect(FACES.map((s) => s.tool).sort()).toEqual([
+      'aggregate_records', 'create_record', 'delete_record', 'delete_records', 'get_record', 'query_records', 'update_record',
+    ]);
+  });
+
+  for (const site of FACES) {
+    it(`${site.tool}: SQLITE_BUSY answers 500 DATABASE_ERROR 'Internal data error', the driver text withheld and logged once`, async () => {
+      const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const thrown = sqliteBusy();
+      const { text, error } = await errorOf(site, thrown);
+      expect(error).toEqual({ code: 'DATABASE_ERROR', message: 'Internal data error', status: 500 });
+      expect(error).toEqual(doorAnswer(thrown));
+      expect(text).not.toContain('SQLITE_BUSY');
+      expect(text).not.toContain('database is locked');
+      expect(log).toHaveBeenCalledTimes(1);
+      const line = String(log.mock.calls[0]![0]);
+      expect(line).toMatch(new RegExp(`^\\[5xx\\] 500 tools/call ${site.tool} task — `));
+      expect(line).toContain('SQLITE_BUSY: database is locked');
+    });
+  }
+
+  const update = FACES.find((s) => s.tool === 'update_record')!;
+
+  it('a driver errno whose text names no store (ECONNRESET) answers the door\'s 500 INTERNAL_ERROR, its code withheld', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    const thrown = Object.assign(new Error('socket hang up'), { code: 'ECONNRESET' });
+    const { text, error } = await errorOf(update, thrown);
+    expect(error).toEqual({ code: 'INTERNAL_ERROR', message: 'Internal server error', status: 500 });
+    expect(error).toEqual(doorAnswer(thrown));
+    expect(text).not.toContain('ECONNRESET');
+  });
+
+  // The ruling's stated cost (`serverFaultProvenance`'s docblock): a producer
+  // that spells a code but declares no status loses that code on a 5xx, at the
+  // door and now here. It keeps it by declaring the status it means.
+  it('a code with no declared status that the door answers as a fault: the door\'s 500, the code not served', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    const thrown = Object.assign(new Error('Locked.'), { code: 'RECORD_LOCKED' });
+    const { error } = await errorOf(update, thrown);
+    expect(error).toEqual({ code: 'INTERNAL_ERROR', message: 'Internal server error', status: 500 });
+    expect(error).toEqual(doorAnswer(thrown));
+  });
+
+  it('CONTROL: a declared ObjectStack code and a coded sandboxed refusal keep their coded answers on every face, unlogged', async () => {
+    const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+    for (const site of FACES) {
+      expect((await errorOf(site, Object.assign(new Error('Locked.'), { code: 'RECORD_LOCKED', status: 409 }))).error, site.tool)
+        .toEqual({ code: 'RECORD_LOCKED', message: 'Locked.', status: 409 });
+      expect((await errorOf(site, codedSandboxRefusal())).error, site.tool)
+        .toEqual({ code: 'RECORD_LOCKED', message: SANDBOX_SENTENCE, status: 409 });
+    }
+    expect(log).not.toHaveBeenCalled();
+  });
+
+  it('CONTROL: a code the door answers as a refusal with no declared status (PERMISSION_DENIED, 403 at the door) keeps its coded answer', async () => {
+    const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+    for (const site of FACES) {
+      expect((await errorOf(site, Object.assign(new Error('Field read denied: salary'), { code: 'PERMISSION_DENIED' }))).error, site.tool)
+        .toEqual({ code: 'PERMISSION_DENIED', message: 'Field read denied: salary' });
+    }
+    expect(log).not.toHaveBeenCalled();
+  });
+
+  // A 5xx the producer DECLARED is not a driver's: its code is authored. The
+  // door withholds a declared 5xx's prose too; that is not this card's face.
+  it('CONTROL: a code with a declared 5xx keeps its coded answer', async () => {
+    const thrown = Object.assign(new Error('The ledger is closing.'), { code: 'SERVICE_UNAVAILABLE', status: 503 });
+    for (const site of FACES) {
+      expect((await errorOf(site, thrown)).error, site.tool)
+        .toEqual({ code: 'SERVICE_UNAVAILABLE', message: 'The ledger is closing.', status: 503 });
+    }
+  });
+});
@@ -50,7 +50,7 @@ import { StandardErrorCode, type ErrorCode } from '@objectstack/spec/api';
 // [#23701] The one key every door that translates the engine's unique-violation
 // envelope asks (the registered code AND the class name, never message text),
 // and the one classification whose arm states the wire code for it.
-import { earnedAnswerOf, isEngineDuplicateRecordEnvelope, isSandboxCrash, isServerFault, logServerFault, mapDataError, resolveQueryReadLimits, sandboxBusinessMessage, staleSummaryAnswerLines, structuredCodeAnswer, type SummaryRecomputeRefusal } from '@objectstack/types';
+import { earnedAnswerOf, isEngineDuplicateRecordEnvelope, isSandboxCrash, isServerFault, logServerFault, mapDataError, resolveQueryReadLimits, resolveThrownHttpError, sandboxBusinessMessage, serverFaultProvenance, staleSummaryAnswerLines, structuredCodeAnswer, type SummaryRecomputeRefusal } from '@objectstack/types';
 import {
   MCP_OAUTH_SCOPE_DATA_READ,
   MCP_OAUTH_SCOPE_DATA_WRITE,
@@ -547,6 +547,37 @@ export function dataDoorAnswerOf(err: unknown, objectName?: string): DataDoorAns
   return { ...(code !== undefined ? { code } : {}), message, status: door.status };
 }
 
+/**
+ * [#31273] {@link thrownRefusalEnvelope} for a face the `/api/v1/data` door
+ * serves: the coded refusal, unless the door answers the throw as a server
+ * fault whose status the producer never declared. That throw is a driver's own
+ * errno on `.code` (`SQLITE_BUSY`, `ECONNRESET`, `40P01`), not a refusal, and
+ * the face answers the door's fault instead: `500 DATABASE_ERROR` `Internal
+ * data error` for `SQLITE_BUSY`, the errno and driver text withheld and logged.
+ * It used to reach the agent as `{ code: 'SQLITE_BUSY', message: <driver
+ * text> }` with no status.
+ *
+ * Both halves are the door's own reads, never a copy: {@link dataDoorAnswerOf}
+ * (`mapDataError`) says "server fault", and `serverFaultProvenance`
+ * (`@objectstack/types`) says "undeclared". The second is the 2026-08-27
+ * ruling on #12509 that withholds a demoted errno at every door: the
+ * discriminator is the status channel, never the code's spelling, so a
+ * producer that spells a code and declares no status loses it on a 5xx, here
+ * as at the door. A code the door refuses (`PERMISSION_DENIED` with no status
+ * answers 403 there) and a code with a declared status keep the coded answer.
+ *
+ * Read by the six record data tools ({@link dataDoorErrorResult}),
+ * `delete_records`' selection read and the record resource
+ * (`MCPServerRuntime.bridgeResources`). ⛔ Not by `run_action` / `resume_run`
+ * or the metadata tools, whose doors are not `/data`.
+ */
+export function dataDoorRefusalEnvelope(err: unknown, objectName: string): ThrownRefusalEnvelope | undefined {
+  const envelope = thrownRefusalEnvelope(err);
+  if (envelope === undefined) return undefined;
+  if (serverFaultProvenance(resolveThrownHttpError(err)) !== 'undeclared') return envelope;
+  return isServerFault(dataDoorAnswerOf(err, objectName).status) ? undefined : envelope;
+}
+
 /**
  * [#31218] The record data tools' tool error: a CODED throw renders exactly as
  * {@link errorResultWithCode} renders it, and a throw with NO code renders the
@@ -573,15 +604,16 @@ export function dataDoorAnswerOf(err: unknown, objectName?: string): DataDoorAns
  *
  * ⛔ The coded path is read FIRST and is unchanged: a thrown `code` keeps
  * {@link thrownRefusalEnvelope}'s rendering byte for byte, its unique-violation
- * spelling included.
+ * spelling included. [#31273] One exception, a driver's own code: see
+ * {@link dataDoorRefusalEnvelope}.
  *
  * Only these six tools. `delete_records` groups its rows through the same door
  * ({@link rowRefusalOf}); its outer catch also renders this file's own
  * code-less sentences, which the door's message heuristics would misread, so
  * it keeps {@link errorResultWithCode}.
  */
-function dataDoorErrorResult(err: unknown, tool: DataDoorTool, objectName: string) {
-  const envelope = thrownRefusalEnvelope(err);
+function dataDoorErrorResult(err: unknown, tool: DataDoorTool | typeof DELETE_RECORDS_TOOL, objectName: string) {
+  const envelope = dataDoorRefusalEnvelope(err, objectName);
   if (envelope) return codedErrorResult({ ...envelope });
   const door = dataDoorAnswerOf(err, objectName);
   if (isServerFault(door.status)) {
@@ -2340,6 +2372,12 @@ export function registerObjectTools(
             }
             return textResult(outcome);
           } catch (err) {
+            // [#31273] A driver's own code from the selection read answers the
+            // door's fault, as the record data tools answer it. Every other
+            // throw keeps this catch's rendering (#31218 says why).
+            if (thrownRefusalEnvelope(err) !== undefined && dataDoorRefusalEnvelope(err, objectName) === undefined) {
+              return dataDoorErrorResult(err, DELETE_RECORDS_TOOL, objectName);
+            }
             return errorResultWithCode(err);
           }
         },
 
@@ -14,7 +14,7 @@ import type {
   ToolRegistry,
   ToolExecutionResult,
 } from './types.js';
-import { wireBridgeTools, grantsAuthoringTools, thrownRefusalEnvelope, dataDoorAnswerOf } from './mcp-http-tools.js';
+import { wireBridgeTools, grantsAuthoringTools, thrownRefusalEnvelope, dataDoorAnswerOf, dataDoorRefusalEnvelope } from './mcp-http-tools.js';
 import { isServerFault, logServerFault } from '@objectstack/types';
 import type {
   McpDataBridge,
@@ -1577,8 +1577,11 @@ export class MCPServerRuntime {
             // sentence; a fault (a bare `Error`, a crash) is the sanitised 500,
             // its thrown text withheld from the client and logged once, as the
             // door logs it.
+            // [#31273] …and so does a driver's own code (`SQLITE_BUSY`), which
+            // the door answers as a fault, not a refusal
+            // (`dataDoorRefusalEnvelope`).
             const uri = `objectstack://objects/${objectName}/records/${recordId}`;
-            const envelope = thrownRefusalEnvelope(err);
+            const envelope = dataDoorRefusalEnvelope(err, objectName);
             let body: { error: string; code?: string; status?: number };
             if (envelope) {
               body = {