@@ -1,50 +1,43 @@
 // Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
 
 /**
- * The Delegator field of `sys_approval_delegation` offers exactly what the
+ * The Delegator picker of `sys_approval_delegation` offers exactly what the
  * delegation write guard admits.
  *
  * `bindDelegationWriteGuard` (lifecycle-hooks.ts) admits one delegator on a
  * non-system write — the acting user — and refuses every other with 403: a
  * delegation names its own author as delegator, and acting for an absent
  * approver is the approval-level override (the guard's docstring holds the
- * ruling). The field used to be a free `sys_user` lookup, so the console's
- * create dialog demanded a choice among every user and the server refused all
- * but one of them. It now declares that one value, in the object vocabulary
- * the create form honours:
- *
- *  - `defaultValue: 'current_user'` — the create form seeds the acting user
- *    (the token the console resolves client-side on a `sys_user` lookup), and
- *    an insert that omits the field stores the acting user;
- *  - `lookupFilters` on `id` = `{current_user_id}` — the picker's candidate
- *    query, whose placeholder the engine resolves against the caller on every
- *    read.
+ * ruling). The field was a free `sys_user` lookup, so the console's create
+ * dialog offered every user and the server refused all but one of them. It
+ * now declares `lookupFilters` on `id` = `{current_user_id}`: the picker's
+ * candidate query, whose placeholder the engine resolves against the caller
+ * on every read.
  *
  * Through a real `ObjectQL` over `SqlDriver` (better-sqlite3, in-memory, real
  * DDL) with the guard bound, this file asserts:
  *
- *  1. the declaration, read off the object;
+ *  1. the declaration, read off the object and off the registered body;
  *  2. the picker's candidate query returns the caller and nobody else, for
  *     each caller;
- *  3. every candidate it offers is admitted by the guard, and a create that
- *     leaves the field empty stores the caller;
+ *  3. every candidate it offers is admitted by the guard;
  *  4. the guard is not widened: a create or an update naming anyone else is
  *     still refused, `FORBIDDEN` / 403, and nothing is stored;
- *  5. `required` stays: a write with no acting user still has no delegator.
+ *  5. `required` stays: a write with no acting user and no delegator is
+ *     refused.
  */
 
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { ObjectQL } from '@objectstack/objectql';
 import { SqlDriver } from '@objectstack/driver-sql';
-import { isCurrentUserDefaultToken } from '@objectstack/spec/data';
 import { SysApprovalDelegation } from './sys-approval-delegation.object.js';
 import { bindDelegationWriteGuard } from './lifecycle-hooks.js';
 
 const OBJECT = 'sys_approval_delegation';
 const SYSTEM = { context: { isSystem: true } } as any;
 const asUser = (userId: string) => ({ context: { userId, positions: [], permissions: [] } }) as any;
 
-/** The install's people: an admin covering for Priya, and two colleagues. */
+/** The install's people: an admin covering for Priya, and a colleague. */
 const USERS = [
   { id: 'u_admin', name: 'Dev Admin' },
   { id: 'u_priya', name: 'Priya Raman' },
@@ -69,8 +62,8 @@ const delegatorField = (): Record<string, any> =>
 /**
  * The picker's candidate `where`, from the declared `lookupFilters`. The
  * console lowers each `eq` entry to `{ [field]: value }` and sends it as the
- * `$filter` of its `sys_user` query (objectui `lookupFiltersToRecord`); every
- * entry here is `eq`, which the declaration test holds.
+ * `$filter` of its `sys_user` query (objectui `lookupFiltersToRecord`); the
+ * declaration test holds that every entry here is `eq`.
  */
 function pickerWhere(): Record<string, unknown> {
   const filters = (delegatorField().lookupFilters ?? []) as LookupFilter[];
@@ -79,7 +72,7 @@ function pickerWhere(): Record<string, unknown> {
   return where;
 }
 
-describe('sys_approval_delegation — the Delegator field offers only what the write guard admits', () => {
+describe('sys_approval_delegation — the Delegator picker offers only what the write guard admits', () => {
   let engine: ObjectQL;
 
   beforeAll(async () => {
@@ -102,20 +95,16 @@ describe('sys_approval_delegation — the Delegator field offers only what the w
     try { await engine?.destroy(); } catch { /* noop */ }
   });
 
-  it('declares the acting user as the default and as the picker\'s only candidate, and stays required', () => {
+  it('declares the acting user as the picker\'s only candidate, and stays a required sys_user lookup', () => {
     const field = delegatorField();
     expect(field.type).toBe('lookup');
     expect(field.reference).toBe('sys_user');
     expect(field.required).toBe(true);
-    // The token the console's create form resolves to the acting user on a
-    // `sys_user` lookup, and the engine stamps at insert.
-    expect(isCurrentUserDefaultToken(field.defaultValue)).toBe(true);
     expect(field.lookupFilters).toEqual([{ field: 'id', operator: 'eq', value: '{current_user_id}' }]);
   });
 
-  it('the registered body keeps both declarations', () => {
+  it('the registered body keeps the declaration', () => {
     const registered = (engine.registry.getObject(OBJECT) as any).fields.delegator_id;
-    expect(isCurrentUserDefaultToken(registered.defaultValue)).toBe(true);
     expect(registered.lookupFilters).toEqual(delegatorField().lookupFilters);
   });
 
@@ -135,15 +124,6 @@ describe('sys_approval_delegation — the Delegator field offers only what the w
     }
   });
 
-  it.each([
-    ['omitted', { delegate_id: 'u_tomas' }],
-    ['null', { delegator_id: null, delegate_id: 'u_tomas' }],
-  ])('a create that leaves the delegator %s stores the acting user', async (_label, data) => {
-    const created = await engine.insert(OBJECT, { ...data }, asUser('u_admin'));
-    const row = await engine.findOne(OBJECT, { where: { id: created.id } } as any, SYSTEM);
-    expect(row?.delegator_id).toBe('u_admin');
-  });
-
   it('the guard is not widened: a create naming anyone else is refused FORBIDDEN / 403 and stores nothing', async () => {
     const before = await engine.count(OBJECT, { where: { delegator_id: 'u_priya' } } as any, SYSTEM);
     await expect(
@@ -153,7 +133,7 @@ describe('sys_approval_delegation — the Delegator field offers only what the w
   });
 
   it('the guard is not widened: an update relabelling the delegator is refused FORBIDDEN / 403', async () => {
-    const own = await engine.insert(OBJECT, { delegate_id: 'u_tomas' }, asUser('u_admin'));
+    const own = await engine.insert(OBJECT, { delegator_id: 'u_admin', delegate_id: 'u_tomas' }, asUser('u_admin'));
     await expect(
       engine.update(OBJECT, { id: own.id, delegator_id: 'u_priya' }, asUser('u_admin')),
     ).rejects.toMatchObject({ code: 'FORBIDDEN', statusCode: 403 });
 
@@ -89,23 +89,15 @@ export const SysApprovalDelegation = ObjectSchema.create({
     // A delegation names its own author as delegator: on every non-system
     // write `bindDelegationWriteGuard` (lifecycle-hooks.ts) admits exactly one
     // value here, the acting user, and refuses any other with 403 (its
-    // docstring holds why there is no admin exemption). So the field declares
-    // that one value in the vocabulary the create form honours, instead of a
-    // free `sys_user` lookup that offered every user and saw all but one
-    // refused:
-    //  - `defaultValue: 'current_user'` — the create form opens on the acting
-    //    user, and an insert that omits the field stores the acting user
-    //    (`applyFieldDefaults`, before the guard runs; the guard stamps the
-    //    same value). `required` stays: a write with no acting user still has
-    //    no delegator, and is refused.
-    //  - `lookupFilters` — the picker's candidate query, which the engine
-    //    resolves `{current_user_id}` in for every read, so it offers the
-    //    acting user and nobody else.
-    // Pinned in `sys-approval-delegation-delegator-picker.test.ts`.
+    // docstring holds why there is no admin exemption). So the picker offers
+    // that one value, instead of every user with all but one refused:
+    // `lookupFilters` is the picker's candidate query, and the engine resolves
+    // `{current_user_id}` against the caller on every read. Presentation only
+    // — the guard stays the enforcement, and what a write may store is
+    // unchanged. Pinned in `sys-approval-delegation-delegator-picker.test.ts`.
     delegator_id: Field.lookup('sys_user', {
       label: 'Delegator',
       required: true,
-      defaultValue: 'current_user',
       lookupFilters: [{ field: 'id', operator: 'eq', value: '{current_user_id}' }],
       group: 'Delegation',
       description: 'The user going out of office; their individually-routed approver slots are rerouted while active.',