@@ -0,0 +1,16 @@
+---
+'@objectstack/runtime': patch
+'@objectstack/plugin-audit': patch
+---
+
+fix(runtime): the two `action_invocation` rows of an `api` action that forwards to another action route name each other
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+A `type: 'api'` action whose `target` is another action route on the same server answers through two doors, so it writes two `sys_audit_log` rows: the outer door's (`branch: 'api'`, `surface: 'mcp'` for an agent's `run_action`, `rest` for a click) and the inner REST door's for the action it reached. The two could only be joined by their timestamps, and the inner row read like a person's direct REST call. Now each row names the other:
+
+- **The outer row's `metadata.target`** is the action's declared `target`, on the `api` branch only. It is the declaration, not the interpolated path: a path built from the caller's params can carry a param value, and this row records no params.
+- **The inner row's `metadata.forwarded_from`** is the forward mark the request arrived carrying (`<object>/<action>` of the outer action), the same `x-objectstack-action-forward` header the inner door already reads for its loop refusal. It is a hint, not a surface: any caller can send the mark, so a forged one mislabels this key and nothing else, and the inner row's `surface: 'rest'` still names the door the request came through. Because the header is caller text bound for the ledger, it is recorded only in the forwarding door's own shape: two snake_case machine names joined by one slash, at most 255 characters. Any other value is left out of the row, and the call is answered exactly as it would be without it.
+
+**Public surface (widening):** `ActionInvocationAuditEvent`, exported by `@objectstack/plugin-audit`, gains two optional members, `target` and `forwardedFrom`. An event that sets neither writes the same row as before. The runtime's matching event type and helpers are internal to `@objectstack/runtime`. Rows written before this change carry neither key.
@@ -198,6 +198,35 @@ describe('[#27908] the action_invocation row tells an agent\'s call from a click
     });
   });
 
+  it('[#28281] an api forward\'s two rows name each other: the outer row its target, the inner row the forward', async () => {
+    const engine = await boot();
+    const writer = createActionInvocationAuditWriter({ getEngine: () => engine as any });
+
+    await writer.recordActionInvocation({
+      context: { userId: 'usr_1', tenantId: 'org_1', surface: 'rest' },
+      actionName: 'nudge_case', objectName: 'crm_case', recordId: 'case_1', branch: 'script', outcome: 'succeeded',
+      forwardedFrom: 'crm_case/forward_case',
+    });
+    await writer.recordActionInvocation({
+      ...AGENT, actionName: 'forward_case', branch: 'api', target: '/api/v1/actions/crm_case/nudge_case',
+    });
+
+    const [inner, outer] = (await ledgerRows(engine)).map((r) => JSON.parse(r.metadata));
+    expect(inner).toEqual({
+      surface: 'rest', action_name: 'nudge_case', branch: 'script', outcome: 'succeeded',
+      forwarded_from: 'crm_case/forward_case',
+    });
+    expect(outer).toEqual({
+      surface: 'mcp', action_name: 'forward_case', branch: 'api', outcome: 'succeeded',
+      target: '/api/v1/actions/crm_case/nudge_case', performed_by: 'cli_agent', on_behalf_of: 'usr_1',
+    });
+  });
+
+  it('[#28281] a target is recorded only on the api branch', () => {
+    const row = buildActionInvocationAuditRow({ ...CLICK, branch: 'flow', target: 'escalate_flow' });
+    expect('target' in JSON.parse(String(row.metadata))).toBe(false);
+  });
+
   it('an object-less action names no object and no record', () => {
     const row = buildActionInvocationAuditRow({ ...CLICK, objectName: undefined, recordId: 'r1' });
     expect(row.object_name).toBeNull();
 
@@ -49,7 +49,14 @@
  *  - `metadata`: `surface`, `action_name`, `branch`, `outcome`, and on a
  *    failure the HTTP `status` and the error's machine code; `run_id` for a
  *    `resume_run`; and `performed_by` / `on_behalf_of` when an agent performed
- *    the call (ADR-0090 D10 rule 4, the same pair the CRUD mirror writes).
+ *    the call (ADR-0090 D10 rule 4, the same pair the CRUD mirror writes);
+ *  - [#28281] the two rows of an `api` forward to another action route name
+ *    each other: the outer row's `target` is the action's declared target
+ *    (the declaration, not the interpolated path, which can carry a param
+ *    value), and the inner row's `forwarded_from` is the forward mark it
+ *    arrived carrying (`<object>/<action>` of the outer action). The mark is
+ *    a HINT, not a surface: a caller can forge it, so it mislabels this key
+ *    and nothing else, and the inner row's `surface` stays its own door's.
  */
 
 import type { IDataEngine } from '@objectstack/spec/contracts';
@@ -100,6 +107,10 @@ export interface ActionInvocationAuditEvent {
   errorCode?: string;
   /** `resume_run` only: the paused run the call continued. */
   runId?: string;
+  /** `api` branch only: the action's declared `target` (the outer row of a forward). */
+  target?: string;
+  /** The forward mark the call arrived carrying (the inner row of a forward) — a hint only. */
+  forwardedFrom?: string;
 }
 
 /** What {@link createActionInvocationAuditWriter} adds to the `audit` slot. */
@@ -158,6 +169,10 @@ export function buildActionInvocationAuditRow(
   }
   const runId = nonEmpty(event.runId);
   if (runId) metadata.run_id = runId;
+  const target = event.branch === 'api' ? nonEmpty(event.target) : undefined;
+  if (target) metadata.target = target;
+  const forwardedFrom = nonEmpty(event.forwardedFrom);
+  if (forwardedFrom) metadata.forwarded_from = forwardedFrom;
   // [ADR-0090 D10 rule 4] The same pair, under the same names, the CRUD mirror
   // writes for a delegated write — present only when an agent performed the
   // call, so the two shapes stay distinguishable by absence.
 
@@ -73,7 +73,7 @@ import type { FlowFailureDetails } from '@objectstack/spec/api';
 import { recordNotFoundError, omitInternalFieldsFromWriteResponse } from '@objectstack/metadata-protocol';
 import { serveStoredMetadataRead, serveStoredMetadataReadsThrough } from './stored-metadata-reader-seam.js';
 import { actorUserFromExecutionContext, resolveActorDisplayName } from './security/actor-user.js';
-import { actionInvocationBranch, actionInvocationFailure, recordActionInvocation, withActionSurface } from './action-invocation-audit.js';
+import { actionInvocationBranch, actionInvocationFailure, actionInvocationTarget, recordActionInvocation, withActionSurface } from './action-invocation-audit.js';
 import type { HttpProtocolContext } from './http-dispatcher.js';
 import {
     GLOBAL_ACTION_OBJECT_KEY,
@@ -3533,6 +3533,7 @@ export async function invokeBusinessAction(deps: ActionExecutionDeps,
         objectName: isObjectLessActionKey(objectName) ? undefined : objectName,
         recordId,
         branch: actionInvocationBranch(action, isDeclarativeUpdateAction(action)),
+        target: actionInvocationTarget(action, isDeclarativeUpdateAction(action)), // #28281: the outer row names where an api forward went
     };
     let answer: any;
     try {
 
@@ -23,7 +23,14 @@ import { assertEngineUpdateDispatch } from '@objectstack/metadata-core';
 
 import { HttpDispatcher } from './http-dispatcher.js';
 import { API_FORWARD_MARK_HEADER } from './action-execution.js';
-import { withActionSurface, actionInvocationBranch, actionInvocationFailure } from './action-invocation-audit.js';
+import {
+    withActionSurface,
+    actionInvocationBranch,
+    actionInvocationFailure,
+    actionInvocationForwardedFrom,
+    actionInvocationTarget,
+    ACTION_FORWARD_MARK_MAX_LENGTH,
+} from './action-invocation-audit.js';
 
 const OBJECT = 'aud_lead';
 const RECORD = 'lead_1';
@@ -35,6 +42,11 @@ const API = {
     target: '/api/v1/aud/ban', recordIdParam: 'userId', ai: ai('Ban the lead.'),
 };
 const FLOW = { name: 'escalate_lead', label: 'Escalate', objectName: OBJECT, type: 'flow', target: 'escalate_flow', ai: ai('Escalate the lead.') };
+/** An api action whose target is ANOTHER action route on this server — the forward #28281 joins. */
+const FORWARD = {
+    name: 'forward_lead', label: 'Forward', objectName: OBJECT, type: 'api',
+    target: `/api/v1/actions/${OBJECT}/${SCRIPT.name}`, ai: ai('Forward the lead to the nudge.'),
+};
 const UPDATE = { name: 'close_lead', label: 'Close', objectName: OBJECT, operation: 'update', patch: { status: 'closed' }, ai: ai('Close the lead.') };
 /** Gated on a capability no caller below holds — the pre-dispatch refusal. */
 const GATED = { ...SCRIPT, name: 'purge_lead', target: 'purge_lead', requiredPermissions: ['aud.purge'] };
@@ -54,7 +66,7 @@ function makeRig(fail: Failing = {}) {
     const objectDef = {
         name: OBJECT,
         fields: { status: { type: 'text' }, owner: { type: 'text' } },
-        actions: [SCRIPT, API, FLOW, UPDATE, GATED],
+        actions: [SCRIPT, API, FLOW, UPDATE, GATED, FORWARD],
     };
     const schemaOf = (n: string) => (n === OBJECT ? objectDef : undefined);
     const ql: any = {
@@ -78,7 +90,7 @@ function makeRig(fail: Failing = {}) {
         insert: vi.fn(),
         delete: vi.fn(),
     };
-    const request = vi.fn(async () => new Response(
+    const request = vi.fn(async (_url: string, _init: RequestInit) => new Response(
         JSON.stringify(fail.api
             ? { success: false, error: { code: 'FORBIDDEN', message: 'The target refused.' } }
             : { success: true, data: { banned: true } }),
@@ -261,6 +273,104 @@ describe('[#27908] the surface is the DOOR\'s — nothing on the request moves i
     });
 });
 
+describe('[#28281] an api forward to another action route: the two rows name each other', () => {
+    /**
+     * The in-process injector routes the forward into the REAL REST action
+     * door, with the headers `forwardApiAction` actually sent — so the inner
+     * row is written by the same door, reading the same mark, as in a server.
+     */
+    function forwardingRig() {
+        const rig = makeRig();
+        const prefix = '/api/v1/actions';
+        rig.request.mockImplementation(async (url: string, init: RequestInit) => {
+            const path = new URL(url).pathname;
+            if (!path.startsWith(`${prefix}/`)) return new Response('{}', { status: 404 });
+            const headers = Object.fromEntries(Object.entries((init.headers ?? {}) as Record<string, string>));
+            const body = typeof init.body === 'string' ? JSON.parse(init.body) : {};
+            const res: any = await rig.dispatcher.handleActions(path.slice(prefix.length), String(init.method ?? 'POST'), body, {
+                request: { headers },
+                environmentId: 'platform',
+                executionContext: { tenantId: 'org_1', systemPermissions: [], userId: 'u_member' },
+            });
+            return new Response(JSON.stringify(res.response.body), {
+                status: res.response.status, headers: { 'content-type': 'application/json' },
+            });
+        });
+        return rig;
+    }
+
+    it('MCP → api → action route: the outer mcp row names the target, the inner rest row names the forward', async () => {
+        const rig = forwardingRig();
+        const out = await rig.viaMcp(FORWARD);
+
+        expect(out.ok).toBe(true);
+        expect(rig.request).toHaveBeenCalledTimes(1);
+        expect(rig.ql.executeAction).toHaveBeenCalledWith(OBJECT, SCRIPT.target, expect.anything());
+        // The inner door answers before the outer door writes, so the inner row lands first.
+        expect(rig.events).toHaveLength(2);
+        const [inner, outer] = rig.events;
+
+        expect(outer.context.surface).toBe('mcp');
+        expect(outer).toMatchObject({
+            actionName: FORWARD.name, objectName: OBJECT, branch: 'api', outcome: 'succeeded', target: FORWARD.target,
+        });
+        expect(outer.forwardedFrom).toBeUndefined();
+
+        expect(inner.context.surface).toBe('rest');
+        expect(inner).toMatchObject({
+            actionName: SCRIPT.name, objectName: OBJECT, branch: 'script', outcome: 'succeeded',
+            forwardedFrom: `${OBJECT}/${FORWARD.name}`,
+        });
+        expect(inner.target).toBeUndefined();
+    });
+
+    it('REST → api → action route names the same pair; a direct call names neither', async () => {
+        const rig = forwardingRig();
+        const res = await rig.viaRest(FORWARD);
+        expect(res.status).toBe(200);
+        const [inner, outer] = rig.events;
+        expect(outer).toMatchObject({ branch: 'api', target: FORWARD.target });
+        expect(outer.context.surface).toBe('rest');
+        expect(inner).toMatchObject({ actionName: SCRIPT.name, forwardedFrom: `${OBJECT}/${FORWARD.name}` });
+
+        const direct = makeRig();
+        await direct.viaRest(SCRIPT);
+        expect(direct.events).toHaveLength(1);
+        expect(direct.events[0].target).toBeUndefined();
+        expect(direct.events[0].forwardedFrom).toBeUndefined();
+    });
+
+    it('the outer row records the DECLARED target, never the path interpolated from the caller\'s params', async () => {
+        const rig = makeRig();
+        await rig.viaMcp(API);
+        const sent = String((rig.request.mock.calls[0] as any[])[0]);
+        expect(sent).toContain('/api/v1/aud/ban');
+        expect(rig.events[0].target).toBe(API.target);
+    });
+
+    it('a forged mark in the forward\'s shape is recorded as the hint it is, and moves nothing else on the row', async () => {
+        const rig = makeRig();
+        const res = await rig.viaRest(SCRIPT, { userId: 'u_member' }, { [API_FORWARD_MARK_HEADER]: 'aud_lead/forged' });
+        expect(res.status).toBe(200);
+        expect(rig.events).toHaveLength(1);
+        expect(rig.events[0]).toMatchObject({ forwardedFrom: 'aud_lead/forged', outcome: 'succeeded', branch: 'script' });
+        expect(rig.events[0].context.surface).toBe('rest');
+    });
+
+    it.each([
+        ['over-long', `aud_lead/${'x'.repeat(4096)}`],
+        ['malformed', 'aud_lead/forward_lead; DROP TABLE sys_audit_log'],
+    ])('a forged %s mark is left out of the row; the call is answered and recorded exactly as without it', async (_kind, mark) => {
+        const rig = makeRig();
+        const res = await rig.viaRest(SCRIPT, { userId: 'u_member' }, { [API_FORWARD_MARK_HEADER]: mark });
+        expect(res.status).toBe(200);
+        expect(rig.events).toHaveLength(1);
+        expect(rig.events[0]).toMatchObject({ actionName: SCRIPT.name, outcome: 'succeeded', branch: 'script' });
+        expect(rig.events[0].forwardedFrom).toBeUndefined();
+        expect(rig.events[0].context.surface).toBe('rest');
+    });
+});
+
 describe('[#27908] MCP resume_run continues a run and writes its own row', () => {
     function resumeRig(resumeAnswer: any) {
         const rig = makeRig();
@@ -310,6 +420,31 @@ describe('[#27908] the helpers', () => {
         expect(actionInvocationBranch(undefined, false)).toBe('script');
     });
 
+    it('actionInvocationTarget names only an api branch\'s declared target', () => {
+        expect(actionInvocationTarget({ type: 'api', target: '/api/v1/x' }, false)).toBe('/api/v1/x');
+        expect(actionInvocationTarget({ type: 'api', target: '/api/v1/x', operation: 'update' }, true)).toBeUndefined();
+        expect(actionInvocationTarget({ type: 'flow', target: 'some_flow' }, false)).toBeUndefined();
+        expect(actionInvocationTarget({ type: 'api', target: '  ' }, false)).toBeUndefined();
+    });
+
+    it('actionInvocationForwardedFrom records only a mark in the forwarding door\'s own shape', () => {
+        const read = (mark: unknown) => actionInvocationForwardedFrom(
+            { request: { headers: { [API_FORWARD_MARK_HEADER]: mark } } } as any, API_FORWARD_MARK_HEADER);
+        expect(read('aud_lead/forward_lead')).toBe('aud_lead/forward_lead');
+        expect(read('global/log_call')).toBe('global/log_call');
+        const longest = `${'a'.repeat(127)}/${'b'.repeat(127)}`;
+        expect(longest).toHaveLength(ACTION_FORWARD_MARK_MAX_LENGTH);
+        expect(read(longest)).toBe(longest);
+        for (const malformed of [
+            '', 'aud_lead', 'aud_lead/', '/forward_lead', 'aud_lead/forward_lead/extra', 'Aud_Lead/forward_lead',
+            'aud_lead/forward lead', ' aud_lead/forward_lead', 'aud_lead/forward_lead\n', '*/log_call', 'a/forward_lead',
+            '1lead/forward_lead', `${'a'.repeat(128)}/${'b'.repeat(127)}`, ['aud_lead/forward_lead'], 42,
+        ]) {
+            expect(read(malformed)).toBeUndefined();
+        }
+        expect(actionInvocationForwardedFrom(undefined, API_FORWARD_MARK_HEADER)).toBeUndefined();
+    });
+
     it('actionInvocationFailure reads a declared status and code, and a bare throw as 500', () => {
         expect(actionInvocationFailure(Object.assign(new Error('x'), { status: 409, code: 'CONFLICT' }))).toEqual({ status: 409, errorCode: 'CONFLICT' });
         expect(actionInvocationFailure(new Error('x')).status).toBe(500);