@@ -0,0 +1,17 @@
+---
+'@objectstack/mcp': patch
+---
+
+fix(mcp): the record resource answers a code-less throw as `/api/v1/data` does, so a sandboxed hook abort no longer shows the hook's name
+
+Clause-②: no
+Metadata-protocol: none
+
+`objectstack://objects/{name}/records/{id}` answered a thrown error that carried no `code` with `{ "error": <thrown message> }`. For a sandboxed hook body's `throw new Error('…')` that message is the runner's debug wrapper, `hook '<name>' threw: Error: …`, so a client saw the hook's internal name, and a fault's own text (a driver error, a crash) reached it verbatim. `GET /api/v1/data/{name}/{id}` answers the same throws `400 HOOK_ABORTED` with the body's sentence, or `500 INTERNAL_ERROR` `Internal server error`.
+
+The resource now answers a code-less throw with the `/data` door's answer, read the way the record data tools read it since the code-less fix for those tools (`mapDataError`, `@objectstack/types`), in the members the resource already uses: `{ "error", "code", "status" }`. A resource reader should expect `code` and `status` on a code-less throw too now. `status` is always set, and `code` is set whenever the door names one:
+
+- an undeclared sandboxed hook abort: `{ "error": "<the body's sentence>", "code": "HOOK_ABORTED", "status": 400 }`;
+- a bare `Error`, or a sandboxed body that crashed (with or without a declared code): `{ "error": "Internal server error", "code": "INTERNAL_ERROR", "status": 500 }`. The thrown text is logged once on the server as a `[5xx]` line instead of being sent.
+
+A coded refusal is answered as before.
@@ -564,12 +564,84 @@ describe('the record resource: a coded refusal adds its code beside the unchange
     expect(coded).not.toContain('RECORD_LOCKED');
   });
 
-  it('a code-less throw answers `{ error }` byte-identically', async () => {
-    expect(await readRefused(new Error('engine exploded'))).toBe(JSON.stringify({ error: 'engine exploded' }));
-    expect(await readRefused('a thrown string')).toBe(JSON.stringify({ error: 'a thrown string' }));
-    expect(await readRefused(Object.assign(new Error('empty code'), { code: '' }))).toBe(
-      JSON.stringify({ error: 'empty code' }),
+  /**
+   * [#31270] A code-less throw answers what the record data tools answer since
+   * #31218: the `/api/v1/data` door's answer (`mapDataError`, the GET by-id
+   * door), in this resource's `{ error, code, status }` members. It used to
+   * answer `{ error }` with the thrown message, so a sandboxed hook's abort
+   * reached the client as the runner's wrapper naming the hook and a fault's
+   * own text reached it verbatim.
+   */
+  describe('a code-less throw answers the /data door\'s answer (#31270)', () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    /** The `SandboxError` the QuickJS runner raises for a hook body's throw (measured on the real runner). */
+    const sandboxed = (inner: string, extra: Record<string, unknown> = {}) => Object.assign(
+      new Error(`hook 'demo_resource_guard' threw: ${inner}`),
+      { name: 'SandboxError', innerMessage: inner.replace(/^Error: /, '') },
+      extra,
     );
+
+    /** The door's answer to `thrown`, in this resource's member order. */
+    function doorBody(thrown: unknown): Record<string, unknown> {
+      const door = mapDataError(thrown, 'task');
+      return {
+        error: door.body.error,
+        ...(typeof door.body.code === 'string' ? { code: door.body.code } : {}),
+        status: door.status,
+      };
+    }
+
+    it('an undeclared sandboxed hook abort: HOOK_ABORTED, the inner sentence, 400; no hook name', async () => {
+      const thrown = sandboxed('Error: Not enough leave');
+      const text = await readRefused(thrown);
+      expect(JSON.parse(text)).toEqual({ error: 'Not enough leave', code: 'HOOK_ABORTED', status: 400 });
+      expect(JSON.parse(text)).toEqual(doorBody(thrown));
+      expect(text).not.toContain('demo_resource_guard');
+      expect(text).not.toContain('threw');
+    });
+
+    it('a bare Error: the sanitised 500, its message withheld and logged once for the operator', async () => {
+      const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const thrown = new Error('socket hang up');
+      const text = await readRefused(thrown);
+      expect(text).toBe(JSON.stringify({ error: 'Internal server error', code: 'INTERNAL_ERROR', status: 500 }));
+      expect(JSON.parse(text)).toEqual(doorBody(thrown));
+      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('socket hang up');
+    });
+
+    it('a sandboxed body that CRASHED, with or without a declared code: the sanitised 500, no hook name, no native text', async () => {
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      for (const thrown of [sandboxed('TypeError: boom'), sandboxed('TypeError: boom', { code: 'RECORD_LOCKED', status: 409 })]) {
+        const text = await readRefused(thrown);
+        expect(text, thrown.message).toBe(JSON.stringify({ error: 'Internal server error', code: 'INTERNAL_ERROR', status: 500 }));
+        expect(text).not.toContain('demo_resource_guard');
+        expect(text).not.toContain('TypeError');
+      }
+    });
+
+    it('a thrown string and an empty `code` are no code: the door\'s answer', async () => {
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      for (const thrown of ['a thrown string', Object.assign(new Error('empty code'), { code: '' })]) {
+        expect(JSON.parse(await readRefused(thrown)), String(thrown)).toEqual(doorBody(thrown));
+      }
+    });
+
+    it('CONTROL: a coded sandboxed refusal keeps the #31246 answer, and a coded non-sandbox refusal its own; neither is logged', async () => {
+      const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(JSON.parse(await readRefused(sandboxed('Error: Locked.', { code: 'RECORD_LOCKED', status: 409 })))).toEqual(
+        { error: 'Locked.', code: 'RECORD_LOCKED', status: 409 },
+      );
+      expect(await readRefused(Object.assign(new Error('The period is closed.'), { code: 'RECORD_LOCKED', status: 409 }))).toBe(
+        JSON.stringify({ error: 'The period is closed.', code: 'RECORD_LOCKED', status: 409 }),
+      );
+      expect(log).not.toHaveBeenCalled();
+    });
   });
 });
 
 
@@ -535,8 +535,11 @@ interface DataDoorAnswer {
  * wrapper, and `Internal server error` for a fault. `object`, `field` and the
  * other context keys the door adds are not read, as `details` is not
  * ({@link errorResultWithCode}).
+ *
+ * [#31270] Exported for the record resource (`MCPServerRuntime.bridgeResources`),
+ * which answers a code-less throw with the same read; not on the package entry.
  */
-function dataDoorAnswerOf(err: unknown, objectName: string): DataDoorAnswer {
+export function dataDoorAnswerOf(err: unknown, objectName: string): DataDoorAnswer {
   const door = mapDataError(err, objectName);
   const code = typeof door.body.code === 'string' && door.body.code !== '' ? door.body.code : undefined;
   const message = typeof door.body.error === 'string' && door.body.error !== '' ? door.body.error : messageOf(err);
 
@@ -14,7 +14,8 @@ import type {
   ToolRegistry,
   ToolExecutionResult,
 } from './types.js';
-import { wireBridgeTools, grantsAuthoringTools, thrownRefusalEnvelope } from './mcp-http-tools.js';
+import { wireBridgeTools, grantsAuthoringTools, thrownRefusalEnvelope, dataDoorAnswerOf } from './mcp-http-tools.js';
+import { isServerFault, logServerFault } from '@objectstack/types';
 import type {
   McpDataBridge,
   McpActionBridge,
@@ -1555,35 +1556,53 @@ export class MCPServerRuntime {
               }],
             };
           } catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
             // [#23509] A coded refusal carries its ADR-0112 `code` (and its
             // `status`, when it has one) beside the sentence, so a client reads
             // the code it branches on. A held owner's key is refused here "with
             // the same code" (ruling C′ item 1) as on REST. The members are
             // ADDED to the body, in the `{ error, code, status }` vocabulary
             // the two sibling resources above already answer with (#6055,
-            // #6504). `error` stays the same string, so a client that tells a
-            // refusal from a row by `typeof body.error === 'string'` still
-            // does. A throw with no code answers `{ error }` as before.
+            // #6504). `error` stays a string, so a client that tells a refusal
+            // from a row by `typeof body.error === 'string'` still does.
             // `details` is withheld, as on the data tools; `errorResultWithCode`
             // in mcp-http-tools.ts says why.
             // [#31246] A coded refusal's `error` is the envelope's sentence,
             // so a sandboxed hook's refusal answers the body's own sentence
             // rather than the runner's wrapper naming the hook, as the tools do.
+            // [#31270] A throw with NO code answers what the record data tools
+            // answer since #31218: the `/api/v1/data` door's answer
+            // (`dataDoorAnswerOf`, the door's own `mapDataError`), in the same
+            // members, so `code` and `status` now appear on a code-less throw
+            // too. A sandboxed hook's abort is `HOOK_ABORTED` with the inner
+            // 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.
+            const uri = `objectstack://objects/${objectName}/records/${recordId}`;
             const envelope = thrownRefusalEnvelope(err);
+            let body: { error: string; code?: string; status?: number };
+            if (envelope) {
+              body = {
+                error: envelope.message,
+                code: envelope.code,
+                ...(envelope.status !== undefined ? { status: envelope.status } : {}),
+              };
+            } else {
+              const door = dataDoorAnswerOf(err, objectName);
+              if (isServerFault(door.status)) {
+                logServerFault({
+                  status: door.status,
+                  error: err,
+                  ...(door.code !== undefined ? { code: door.code } : {}),
+                  request: { method: 'resources/read', path: uri },
+                });
+              }
+              body = { error: door.message, ...(door.code !== undefined ? { code: door.code } : {}), status: door.status };
+            }
             return {
               contents: [{
-                uri: `objectstack://objects/${objectName}/records/${recordId}`,
+                uri,
                 mimeType: 'application/json',
-                text: JSON.stringify(
-                  envelope
-                    ? {
-                        error: envelope.message,
-                        code: envelope.code,
-                        ...(envelope.status !== undefined ? { status: envelope.status } : {}),
-                      }
-                    : { error: message },
-                ),
+                text: JSON.stringify(body),
               }],
             };
           }