feat(approvals): the action log returns acted_as beside the person

listActions maps sys_approval_action.acted_as onto ApprovalActionRow.acted_as
(declared by @objectstack/spec in #21458), so a timeline shows who acted and as
which slot; a row no slot admitted omits it. Pinned with a backfilled row that
shows its slot and no person.

Claude-Session: https://claude.ai/code/session_01DiCSbmJrkzNhuEAier4VoJ
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

.changeset/21411-approval-actor-person.md

@@ -19,6 +19,7 @@ Clause-②: no
   - The multi-approver tally and `decision_progress` count `acted_as`.
   - A participant who already acted keeps sight of a request by either of two facts: `actor_id` is their user id, or `acted_as` is a slot they act under (so a decision taken as `position:<name>` stays visible to that position's holders).
   - Nothing compares a slot with `actor_id` any more.
+  - The action log (`GET /api/v1/approvals/requests/:id/actions`, `listActions`) returns `acted_as` beside `actor_id` and `actor_name`, filling the `ApprovalActionRow.acted_as` member `@objectstack/spec` declares. It is omitted when the action took no slot, or when no stored record kept the slot.
 - **Stored rows.** A repair runs on every boot and is idempotent.
   - Pass 1: a row whose `actor_id` still holds a slot address gets `acted_as` set to it and `actor_id` cleared. No stored record names who decided it, so it shows the slot and no person.
   - Pass 2: the approve votes a still-pending request's tally counts get their `acted_as`, so in-flight `unanimous`, `quorum` and `per_group` requests keep the approvals they already collected.

packages/plugins/plugin-approvals/src/approval-service.test.ts

@@ -4089,6 +4089,30 @@ describe('ApprovalService — actor_id records the person, acted_as the slot (#2
     expect(await svc.getRequest(req.id, holding('u_holder', [])), 'the person, position lost').not.toBeNull();
   });
 
+  it('the action log shows the person by name and the slot beside it — and a backfilled row the slot alone', async () => {
+    const engine = makeFakeEngine();
+    await engine.insert('sys_user', { id: 'u_holder', name: 'Hana Holder', email: 'hana@example.com' });
+    const svc = svcFor(engine);
+    const req = await open(svc, [...toPosition, { type: 'user', value: 'u9' }], 'unanimous');
+    await svc.decideNode(req.id, { decision: 'approve' } as any, HOLDER);
+    // A row as the boot-time backfill leaves a pre-acted_as slot literal: the
+    // slot kept, the person unknown.
+    await engine.insert('sys_approval_action', {
+      id: 'aact_backfilled', request_id: req.id, step_index: 0, action: 'comment',
+      actor_id: null, acted_as: SLOT, comment: 'older note', created_at: '2099-01-01T00:00:00.000Z',
+    });
+
+    const log = await svc.listActions(req.id, SYS);
+    const approve = log.find((a) => a.action === 'approve')!;
+    expect([approve.actor_id, approve.actor_name, approve.acted_as]).toEqual(['u_holder', 'Hana Holder', SLOT]);
+    // The submitter's own action took no slot: no acted_as member at all.
+    const submit = log.find((a) => a.action === 'submit')!;
+    expect(submit.actor_id).toBe('u1');
+    expect('acted_as' in submit && submit.acted_as !== undefined).toBe(false);
+    const backfilled = log.find((a) => a.id === 'aact_backfilled')!;
+    expect([backfilled.actor_id, backfilled.actor_name, backfilled.acted_as]).toEqual([undefined, undefined, SLOT]);
+  });
+
   it('already acted: a row written before acted_as existed is found by its person, and a slot is never matched against actor_id', async () => {
     const engine = makeFakeEngine();
     const svc = svcFor(engine);

packages/plugins/plugin-approvals/src/approval-service.ts

@@ -1145,6 +1145,12 @@ function rowFromAction(row: any): ApprovalActionRow {
     // `null` (a row written before the column existed) stays `undefined`:
     // "not recorded" is not the same claim as "not an override".
     via_override: row.via_override == null ? undefined : row.via_override === true,
+    // #21411 / #21458 — the slot the action was taken as, beside the person in
+    // `actor_id`, so the action log shows both: "who" and "as which slot". A
+    // row no slot admitted (the submitter's own actions, a system action, an
+    // override) — or one recorded before the column, whose slot nothing kept —
+    // omits it: the contract's "not recorded" case, never an empty string.
+    acted_as: typeof row.acted_as === 'string' && row.acted_as !== '' ? row.acted_as : undefined,
     // Decision attachments (#3266): rich descriptors carrying the display name +
     // download URL, so consumers label/open them without reading `sys_file`.
     attachments: attachments.length ? attachments : undefined,
@@ -6987,9 +6993,11 @@ export class ApprovalService implements IApprovalService {
       context: SYSTEM_CTX,
     });
     const actions = Array.isArray(rows) ? rows.map(rowFromAction) : [];
-    // Timeline display: resolve actor ids to names so the audit trail never
-    // shows a raw identifier. Role/team literals are already readable. The
-    // reassign hand-off parties (#4365) resolve through the same batch.
+    // Timeline display: resolve the PERSON in `actor_id` to a name so the
+    // audit trail never shows a raw identifier. The slot the action was taken
+    // as travels beside it in `acted_as`, as stored — the "acting as" half of
+    // the line (#21411). The reassign hand-off parties (#4365) resolve through
+    // the same batch; a `type:value` literal or a machine sentinel is skipped.
     const names = await this.resolveUserNames(
       actions
         .flatMap(a => [a.actor_id, a.reassign_from, a.reassign_to])