@@ -0,0 +1,8 @@
+---
+'@objectstack/mcp': patch
+---
+
+Clause-②: no
+Metadata-protocol: none
+
+The MCP record data tools (`query_records`, `aggregate_records`, `get_record`, `create_record`, `update_record`, `delete_record`, `delete_records`' selection read) and the `objectstack://objects/{name}/records/{id}` resource now answer a coded throw that declares a 5xx the way `/api/v1/data` does. The code and status are kept and the producer's sentence is withheld (`Internal server error`), unless the throw marks itself `refusal: true`; the thrown text is logged once on the server. They used to hand the agent the producer's own sentence. An unregistered code with a declared 5xx answers the status's closed code, as at the door, which names the producer's spelling only in `declaredCode`, a member no MCP face serves. A declared refusal status (below 500) keeps its coded answer unchanged.
@@ -693,15 +693,49 @@ describe('the record resource: a coded refusal adds its code beside the unchange
       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 () => {
+    it('CONTROL: a code the door refuses with no status keeps its coded answer, 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();
     });
   });
+
+  /**
+   * [#31341] A coded throw that DECLARES a 5xx answers the door's answer here
+   * too, through the same predicate the record data tools ask (their block,
+   * below, says why). This row was #31273's CONTROL, which pinned the
+   * producer's sentence served.
+   */
+  describe('a declared 5xx answers the /data door\'s answer, its sentence withheld unless it is a refusal (#31341)', () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('SERVICE_UNAVAILABLE / 503: code and status kept, the sentence withheld and logged once', async () => {
+      const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const thrown = ledgerClosing();
+      const text = await readRefused(thrown);
+      expect(text).toBe(JSON.stringify({ error: 'Internal server error', code: 'SERVICE_UNAVAILABLE', status: 503 }));
+      const door = mapDataError(thrown, 'task');
+      expect(JSON.parse(text)).toEqual({ error: door.body.error, code: door.body.code, status: door.status });
+      const lines = [...error.mock.calls, ...warn.mock.calls].map((call) => String(call[0]));
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toMatch(/^\[5xx\] 503 resources\/read objectstack:\/\/objects\/task\/records\/t1 — /);
+      expect(lines[0]).toContain('The ledger is closing.');
+    });
+
+    it('a declared 503 that marks itself `refusal: true` keeps its sentence, as the door serves it', async () => {
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const thrown = ledgerClosing({ refusal: true });
+      const text = await readRefused(thrown);
+      expect(text).toBe(JSON.stringify({ error: 'The ledger is closing.', code: 'SERVICE_UNAVAILABLE', status: 503 }));
+      const door = mapDataError(thrown, 'task');
+      expect(JSON.parse(text)).toEqual({ error: door.body.error, code: door.body.code, status: door.status });
+    });
+  });
 });
 
 /**
@@ -1026,6 +1060,11 @@ describe('the metadata tools and list_actions: a fault answers what the /meta do
  * 2026-08-27 on #12509: the discriminator is the status channel, never the
  * code's spelling). Then the face answers the door's fault.
  *
+ * [#31341] A coded throw that DECLARES a 5xx is a server fault at the door
+ * too, so the faces now answer it the same way: the door's code and status,
+ * its sentence withheld unless the throw marks itself `refusal: true`. Its
+ * rows close this block; they replaced #31273's CONTROL for a declared 5xx.
+ *
  * 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,
@@ -1035,6 +1074,11 @@ function sqliteBusy(): Error {
   return Object.assign(new Error('SQLITE_BUSY: database is locked'), { code: 'SQLITE_BUSY' });
 }
 
+/** [#31341] A producer's coded throw that declares a 5xx, with its own sentence. */
+function ledgerClosing(extra: Record<string, unknown> = {}): Error {
+  return Object.assign(new Error('The ledger is closing.'), { code: 'SERVICE_UNAVAILABLE', status: 503 }, extra);
+}
+
 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');
 
@@ -1121,13 +1165,53 @@ describe('the record data tools: a driver\'s own string code is the /data door\'
     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 });
+  /**
+   * [#31341] A 5xx the producer DECLARED is a server fault at the door too:
+   * `mapDataError` keeps its code and status and withholds its sentence
+   * (`Internal server error`) unless the throw marks itself `refusal: true`
+   * (`declaredRefusalMessage`, `@objectstack/types`). These faces read the
+   * coded path first, so they served the producer's sentence verbatim. This
+   * row was #31273's CONTROL, which pinned that sentence served; it moved.
+   */
+  for (const site of FACES) {
+    it(`${site.tool}: a declared 5xx keeps its code and status, its sentence withheld and logged once (#31341)`, async () => {
+      const errorLog = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const warnLog = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const thrown = ledgerClosing();
+      const { text, error } = await errorOf(site, thrown);
+      expect(error).toEqual({ code: 'SERVICE_UNAVAILABLE', message: 'Internal server error', status: 503 });
+      expect(error).toEqual(doorAnswer(thrown));
+      expect(text).not.toContain('The ledger is closing.');
+      const lines = [...errorLog.mock.calls, ...warnLog.mock.calls].map((call) => String(call[0]));
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toMatch(new RegExp(`^\\[5xx\\] 503 tools/call ${site.tool} task — `));
+      expect(lines[0]).toContain('The ledger is closing.');
+    });
+  }
+
+  it('a declared 5xx that marks itself `refusal: true` keeps its sentence on every face, as the door serves it (#31341)', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const thrown = ledgerClosing({ refusal: true });
     for (const site of FACES) {
-      expect((await errorOf(site, thrown)).error, site.tool)
-        .toEqual({ code: 'SERVICE_UNAVAILABLE', message: 'The ledger is closing.', status: 503 });
+      const { error } = await errorOf(site, thrown);
+      expect(error, site.tool).toEqual({ code: 'SERVICE_UNAVAILABLE', message: 'The ledger is closing.', status: 503 });
+      expect(error, site.tool).toEqual(doorAnswer(thrown));
     }
   });
+
+  // [#31341] The door demotes an unregistered code with a declared 5xx to the
+  // status's closed code and names the producer's spelling in `declaredCode`,
+  // a member these faces do not serve (as the metadata tools do not, #31272).
+  // So the face answers the closed code. A producer keeps its own code on the
+  // wire by registering it or by throwing a 4xx refusal.
+  it('an unregistered code with a declared 5xx answers the door\'s closed code, its sentence withheld (#31341)', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const thrown = Object.assign(new Error('The vendor is down.'), { code: 'VENDOR_DOWN', status: 503 });
+    const { text, error } = await errorOf(update, thrown);
+    expect(error).toEqual({ code: 'SERVICE_UNAVAILABLE', message: 'Internal server error', status: 503 });
+    expect(error).toEqual(doorAnswer(thrown));
+    expect(text).not.toContain('The vendor is down.');
+  });
 });
@@ -575,23 +575,39 @@ export function dataDoorAnswerOf(err: unknown, objectName?: string): DataDoorAns
 }
 
 /**
- * [#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.
+ * [#31273, #31341] {@link thrownRefusalEnvelope} for a face the `/api/v1/data`
+ * door serves: the coded refusal, unless the door answers the throw as a
+ * server fault. Then the face answers the door's fault instead
+ * ({@link dataDoorAnswerOf}), logged once, which is {@link rowRefusalOf}'s
+ * line drawn with the same reader.
+ *
+ * Two kinds of coded throw are faults at the door:
+ *
+ * - a driver's own errno on `.code` (`SQLITE_BUSY`, `ECONNRESET`, `40P01`),
+ *   with no declared status (#31273). `SQLITE_BUSY` answers `500
+ *   DATABASE_ERROR` `Internal data error`, the errno and driver text withheld.
+ *   It used to reach the agent as `{ code: 'SQLITE_BUSY', message: <driver
+ *   text> }` with no status. The ruling of 2026-08-27 on #12509 says why the
+ *   code goes: 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 with a DECLARED 5xx (#31341), such as `{ code:
+ *   'SERVICE_UNAVAILABLE', status: 503 }`. The door keeps the code and status
+ *   and withholds the producer's sentence (`Internal server error`) unless
+ *   the throw marks itself `refusal: true` (`declaredRefusalMessage`,
+ *   `@objectstack/types`). It used to reach the agent with its own sentence.
+ *   An unregistered code is demoted there to the status's closed code, with
+ *   the producer's spelling in a `declaredCode` member that no MCP face
+ *   serves; the face answers the closed code.
+ *
+ * ⛔ One reader, never a copy of the withhold rule: the door's answer is
+ * `mapDataError`'s, through {@link dataDoorAnswerOf}, and the fault line is
+ * the doors' own `isServerFault`. The question is asked only of a throw whose
+ * status is a 5xx or undeclared (`serverFaultProvenance`, `@objectstack/types`,
+ * answers `'declared'` or `'undeclared'`): a producer that DECLARED a refusal
+ * status (below 500) keeps its coded answer byte for byte, as #31246 pins it,
+ * and so does a code the door refuses (`PERMISSION_DENIED` with no status
+ * answers 403 there).
  *
  * Read by the six record data tools ({@link dataDoorErrorResult}),
  * `delete_records`' selection read and the record resource
@@ -601,7 +617,7 @@ export function dataDoorAnswerOf(err: unknown, objectName?: string): DataDoorAns
 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;
+  if (serverFaultProvenance(resolveThrownHttpError(err)) === undefined) return envelope;
   return isServerFault(dataDoorAnswerOf(err, objectName).status) ? undefined : envelope;
 }
 
@@ -631,7 +647,8 @@ export function dataDoorRefusalEnvelope(err: unknown, objectName: string): Throw
  *
  * ⛔ 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. [#31273] One exception, a driver's own code: see
+ * spelling included. [#31273, #31341] Except where the door answers the coded
+ * throw as a server fault (a driver's own code, a declared 5xx): see
  * {@link dataDoorRefusalEnvelope}.
  *
  * Only these six tools. `delete_records` groups its rows through the same door
@@ -2406,9 +2423,10 @@ 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).
+            // [#31273, #31341] A coded throw from the selection read that the
+            // door answers as a fault (a driver's own code, a declared 5xx)
+            // 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);
             }
 
@@ -1577,9 +1577,10 @@ 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`).
+            // [#31273, #31341] …and so does a coded throw the door answers as a
+            // fault, not a refusal (`dataDoorRefusalEnvelope`): a driver's own
+            // code (`SQLITE_BUSY`), or a declared 5xx, whose code and status
+            // are kept and whose sentence is withheld unless `refusal: true`.
             const uri = `objectstack://objects/${objectName}/records/${recordId}`;
             const envelope = dataDoorRefusalEnvelope(err, objectName);
             let body: { error: string; code?: string; status?: number };