@@ -549,6 +549,7 @@ export {
   type UserWorkEngine,
   type UserAssignedWorkCount,
   type UserAssignedWorkSummary,
+  type UserWorkFailureDescriber,
   type UserWorkTransferFailure,
   type UserWorkTransferOutcome,
   type UserWorkTransferReport,
 
@@ -264,6 +264,14 @@ const CALLERS: Record<string, Classification> = {
       'the validation-predicate reads (`resolvePredicateRelated`: a pass/fail verdict, the value never served), and ' +
       "`resolveOneHopRelated`, the one-hop loader they and the formula fields read through, as the caller's own `find`",
   },
+  // [#30205] A user's assigned work: which fields hold work for a user.
+  'packages/core/src/security/user-assigned-work.ts': {
+    kind: 'not-a-served-read',
+    reason:
+      'picks the fields whose target is the user object, then counts and updates rows of the object that DECLARES ' +
+      'them, under the caller\'s own context; the only read of the target is the hand-over recipient\'s ban state ' +
+      '(a fixed platform object), and no field of it is served',
+  },
   'packages/objectql/src/integrity/dangling-reference-audit.ts': {
     kind: 'not-a-served-read',
     reason: 'an integrity audit: it probes whether a stored id resolves and reports ids, never a field of the target',
 
@@ -196,6 +196,17 @@ describe('[#30205] transferUserAssignedWork', () => {
     expect(engine.tables.get('account')![0].owner_id).toBe('u_gone');
   });
 
+  it('a serving door may word a refused row the way its own write door answers it', async () => {
+    const engine = fakeEngine(seed(), { refuseUpdate: (object, id) => object === 'ticket' && id === 't2' });
+    const seen: string[] = [];
+    const report = await transferUserAssignedWork(engine, 'u_gone', 'u_next', CALLER, {
+      objects: ['ticket'],
+      describeFailure: (_err, object) => { seen.push(object); return { code: 'FORBIDDEN', message: 'You may not change this record' }; },
+    });
+    expect(report.objects[0].failures).toEqual([{ id: 't2', code: 'FORBIDDEN', message: 'You may not change this record' }]);
+    expect(seen).toEqual(['ticket']);
+  });
+
   it('moves at most the row cap per call and answers what remains', async () => {
     const engine = fakeEngine(seed());
     const first = await transferUserAssignedWork(engine, 'u_gone', 'u_next', CALLER, { rowCap: 3 });
 
@@ -241,7 +241,16 @@ export interface UserWorkTransferReport {
   remaining: number;
 }
 
-function failureOf(id: unknown, err: unknown): UserWorkTransferFailure {
+/**
+ * How a serving door words a refused row: the code and the caller-facing
+ * sentence its own write door would answer for the same throw. `undefined`
+ * keeps the raw reading below.
+ */
+export type UserWorkFailureDescriber = (err: unknown, object: string) => { code: string; message: string } | undefined;
+
+function failureOf(id: unknown, err: unknown, object: string, describe?: UserWorkFailureDescriber): UserWorkTransferFailure {
+  const described = describe?.(err, object);
+  if (described) return { id: String(id), code: described.code, message: described.message.slice(0, 500) };
   const e = err as { code?: unknown; message?: unknown } | null;
   return {
     id: String(id),
@@ -263,7 +272,7 @@ export async function transferUserAssignedWork(
   fromUserId: string,
   toUserId: string,
   context: unknown,
-  options: { objects?: readonly string[]; rowCap?: number } = {},
+  options: { objects?: readonly string[]; rowCap?: number; describeFailure?: UserWorkFailureDescriber } = {},
 ): Promise<UserWorkTransferReport> {
   if (fromUserId === toUserId) {
     throw new UserWorkTransferRefusal(400, 'VALIDATION_ERROR', 'toUserId must name a different user than the one whose work is transferred');
@@ -312,7 +321,7 @@ export async function transferUserAssignedWork(
         outcome.updated += 1;
       } catch (err) {
         outcome.failed += 1;
-        if (outcome.failures.length < USER_WORK_FAILURE_SAMPLE) outcome.failures.push(failureOf(row.id, err));
+        if (outcome.failures.length < USER_WORK_FAILURE_SAMPLE) outcome.failures.push(failureOf(row.id, err, ref.object, options.describeFailure));
       }
     }
     try {
 
@@ -153,6 +153,8 @@ const SLOT_FILES = [
     'batch-routes.ts',
     'meta-object-state-routes.ts',
     'meta-item-history-routes.ts',
+    // [#30205] A user's assigned work: the counts and the hand-over (the SIXTH consumer).
+    'user-work-routes.ts',
 ] as const;
 const SOURCES = new Map<string, string>(SLOT_FILES.map((file) => [
     file, file === 'rest-server.ts' ? SOURCE : readFileSync(resolve(HERE, file), 'utf8'),
@@ -228,12 +230,13 @@ describe('[#18546] §1 the `objectQLProvider` consumer census is mechanical', ()
         // 5 UNCHANGED, over four files: 2 in `rest-server.ts` (the class head's
         // two), the batch door's 1, the state-machine read's 1 in
         // `meta-object-state-routes.ts` and `/published`'s 1 in
-        // `meta-item-history-routes.ts`.
+        // `meta-item-history-routes.ts`. [#30205] 6: a user's assigned work, its
+        // one site in `user-work-routes.ts`, shared by both of its routes.
         const sites = censusInvocationSites('objectQLProvider');
         // The message carries the sites, so a failure here hands the next
         // reader the new census instead of a bare number.
         expect(sites.map((s) => `${s.file}:${s.line}: ${s.text}`).join('\n')).toBeTruthy();
-        expect(sites).toHaveLength(5);
+        expect(sites).toHaveLength(6);
     });
 
     it('⭐ [#18559] ALL FIVE consumers reach the slot through `wiredEngineOrLoud` — none reads it directly', () => {
@@ -249,7 +252,7 @@ describe('[#18546] §1 the `objectQLProvider` consumer census is mechanical', ()
         // the site rather than a bare number.
         expect(direct.map((s) => `${s.file}:${s.line}: ${s.text}`).join('\n')).toBe('');
         expect(direct).toHaveLength(0);
-        expect(viaSeam).toHaveLength(5);
+        expect(viaSeam).toHaveLength(6);
 
         // ⭐ CONTROL for the window predicate itself, on BOTH axes. It reads a
         // WINDOW of source text, so "3 of 3" is only a reading if the same
 
@@ -397,6 +397,8 @@ const DISPOSITIONS: Record<string, Disposition> = {
   'POST /api/v1/security/suggested-bindings/:id/dismiss': { kind: 'no-record-echo', why: 'Dismissal receipt.' },
   'POST /api/v1/security/suggested-bindings/:id/reopen': { kind: 'no-record-echo', why: 'Re-open receipt.' },
   'POST /api/v1/security/explain': { kind: 'no-record-echo', why: 'Permission explanation verdict.' },
+  // [#30205] The hand-over answers per-field counts and failed row ids, never a record.
+  'POST /api/v1/security/users/:id/assigned-work/transfer': { kind: 'no-record-echo', why: 'Transfer report: per-field counts and failed row ids (id, code, refusal sentence), never a record body.' },
 
   // Import: per-row RECEIPTS (row number, action, id, warnings/errors) plus
   // counts — measured, the written row is never spread into a result.
 
@@ -154,13 +154,22 @@ function boot(error: () => Error, protocol: Record<string, Fn> = {}): Booted {
     }
     const service = (label: string) => async () => rejecting(label, calls, error);
     const caller = { userId: 'u1', systemPermissions: ['manage_metadata', 'manage_platform_settings'] };
-    const engine = { transaction: async (fn: Fn) => fn({}) };
+    // [#30205] The assigned-work hand-over reads and writes through the data
+    // engine itself: one user field to move, an active target, and a row whose
+    // `update` the refusal reaches.
+    const engine = {
+        transaction: async (fn: Fn) => fn({}),
+        getConfigs: () => ({ [OBJECT]: { name: OBJECT, fields: { owner_id: { type: 'lookup', reference: 'sys_user' } } } }),
+        find: async (object: string) => (object === 'sys_user' ? [{ id: 'u2', banned: false }] : [{ id: 'r1' }]),
+        count: async () => 0,
+        update: async () => { calls.push('engine.update'); throw error(); },
+    };
     const rest = new RestServer(
         server,
         rejecting('protocol', calls, error, recorded),
         { api: { requireAuth: false } } as any,
         undefined, undefined, undefined, undefined,
-        async () => engine,                 // objectQLProvider (`POST /batch`)
+        async () => engine,                 // objectQLProvider (`POST /batch`, the assigned-work hand-over)
         service('email'),
         service('sharing'),
         undefined,                          // retired slot
@@ -341,6 +350,12 @@ const ANSWERS_THE_SENTENCE: Record<string, Driver> = {
         },
     },
     'POST /api/v1/security/explain': { called: 'security.explain', body: { object: OBJECT, operation: 'read' } },
+    // [#30205] The hand-over answers per row, inside its `200`: a refused row's
+    // entry in `failures` carries the `/data` door's sentence for that throw.
+    'POST /api/v1/security/users/:id/assigned-work/transfer': {
+        called: 'engine.update', body: { toUserId: 'u2' },
+        answer: (res) => res.body?.data?.objects?.[0]?.failures?.[0]?.message,
+    },
     'POST /api/v1/data/:object/:id/shares': { called: 'sharing.grant', body: {} },
     'DELETE /api/v1/data/:object/:id/shares/:shareId': { called: 'sharing.revoke' },
     'POST /api/v1/batch': {
 
@@ -37,6 +37,7 @@ import {
     UserWorkTransferRefusal,
     type UserWorkEngine,
 } from '@objectstack/core';
+import { handleRouteError } from './error-response.js';
 import { refuseUnknownQueryParams } from './query-allowlist.js';
 import { wiredEngineOrLoud, type RestServer } from './rest-server.js';
 
@@ -55,6 +56,25 @@ export const USER_WORK_QUERY_PARAMS: readonly string[] = [];
 /** The keys a transfer body may carry. */
 const TRANSFER_BODY_KEYS = new Set(['toUserId', 'objects']);
 
+/**
+ * A refused row, worded the way the `/data` write door answers the same throw:
+ * the shared classification (`handleRouteError`) sent to a sink, so a hook's
+ * refusal reads as the hook's sentence, a crash or a store fault has its words
+ * withheld and is logged, and nothing here is a second rule.
+ */
+function rowFailureAnswer(err: unknown, object: string): { code: string; message: string } {
+    const sink: { body?: Record<string, unknown>; status(code: number): typeof sink; json(body: Record<string, unknown>): typeof sink } = {
+        status() { return sink; },
+        json(body) { sink.body = body; return sink; },
+    };
+    handleRouteError(sink, err, object);
+    const body = sink.body ?? {};
+    return {
+        code: typeof body.code === 'string' && body.code.length > 0 ? body.code : 'UPDATE_FAILED',
+        message: typeof body.error === 'string' ? body.error : 'The record could not be updated',
+    };
+}
+
 /**
  * Register the assigned-work routes — `RestServer#registerUserWorkEndpoints`'
  * body, called by that method with the server as `this`.
@@ -127,7 +147,10 @@ export function registerUserWorkEndpoints(this: UserWorkRouteHost, basePath: str
                 const engine = await resolveEngine(environmentId, req);
                 if (!engine) return sendError(res, 501, 'NOT_IMPLEMENTED', 'No data engine is configured on this deployment');
                 try {
-                    const report = await transferUserAssignedWork(engine, userId, toUserId, context, { objects });
+                    const report = await transferUserAssignedWork(engine, userId, toUserId, context, {
+                        objects,
+                        describeFailure: rowFailureAnswer,
+                    });
                     return res.json({ success: true, data: report });
                 } catch (err) {
                     if (!(err instanceof UserWorkTransferRefusal)) throw err;