@@ -0,0 +1,12 @@
+---
+'@object-ui/core': patch
+---
+
+fix(core): a row action's `${ctx.recordId}` and `${ctx.record.*}` target holes read the row it was opened on
+
+Clause-②: no
+Metadata-protocol: none
+
+A `type: 'url'` action shown in a list view's row menu (`locations: ['list_item']`) interpolated `${ctx.recordId}` and `${ctx.record.*}` to empty, so a target such as `/apps/APP/OBJECT/record/${ctx.recordId}/page/PAGE` opened `/apps/APP/OBJECT/record/page/PAGE`. The same action in the record header worked. The row menu dispatches the clicked row under `params._rowRecord` through the page's action runner, and the runner built the `ctx` scope from its own context, which on a list page names no record.
+
+Now a dispatch that carries a row binds `ctx.record` to that row and `ctx.recordId` to its `id` for target interpolation: `type: 'url'` targets, `type: 'api'` targets and the `onSuccess.navigate` hop. The row wins over a page-level record, so a related-list row on a record page reads the child row. This is the rule the runner already applied to a row action's copy templates. `${ctx.selection.ids}` and `${ctx.selection.count}` are unchanged: they stay the grid's checked selection, which opening a row menu does not change.
@@ -2997,7 +2997,9 @@ export class ActionRunner {
    * fragment.
    *
    * `ctx.origin`, `ctx.user.*`, `ctx.org.*`, `ctx.recordId` are surfaced
-   * implicitly from the runner's ActionContext + window, and
+   * implicitly from the runner's ActionContext + window; a dispatch that
+   * carries a row binds `ctx.record` / `ctx.recordId` to that row (see
+   * `buildInterpolationContext`), and
    * `ctx.selection.ids` / `ctx.selection.count` reflect the grid's current
    * checkbox selection (`context.selectedRecords`) — `${ctx.selection.ids}`
    * comma-joins the ids via the standard `String(array)` behaviour, so a
@@ -3059,7 +3061,7 @@ export class ActionRunner {
     // (`composeSuccessMessage`, until objectstack#27948's step 2 retires it):
     // `result` only, because that is the one scope the contract declares for the
     // copy, and no encoding, because a toast is text.
-    const scopes: Record<string, unknown> = { param: params, ctx: this.buildInterpolationContext() };
+    const scopes: Record<string, unknown> = { param: params, ctx: this.buildInterpolationContext(action) };
     if (resultScope !== undefined) scopes.result = resultScope;
     return substituteScopeTokens(target, scopes, encodeURIComponent);
   }
@@ -3068,8 +3070,19 @@ export class ActionRunner {
    * Assemble the `ctx` namespace exposed to target interpolation.
    * Built-in keys: origin, user, org, recordId. Anything the consumer
    * placed under context.ctx is merged on top.
-   */
-  private buildInterpolationContext(): Record<string, unknown> {
+   *
+   * The record is the one the dispatch runs against, the rule
+   * `templateEvaluatorFor` applies to copy templates (objectui#12967). A row
+   * surface (a list view's row menu, a related list's rows) stashes the clicked
+   * row under `params._rowRecord` and fires through a runner whose context
+   * names the page, not the row. So when the dispatch carries a row,
+   * `ctx.record` is that row and `ctx.recordId` its `id`, over both the
+   * runner's own record and the `ctx` mirror: a related-list row on a record
+   * page is the child, not the page's record. `ctx.selection` is untouched:
+   * it stays the grid's checkbox selection, which a row dispatch does not
+   * change.
+   */
+  private buildInterpolationContext(action: ActionDef): Record<string, unknown> {
     const ctx: Record<string, unknown> = {
       origin: typeof window !== 'undefined' ? window.location.origin : '',
       // Backend API origin (typically `import.meta.env.VITE_SERVER_URL`
@@ -3102,6 +3115,11 @@ export class ActionRunner {
     if (this.context.ctx && typeof this.context.ctx === 'object') {
       Object.assign(ctx, this.context.ctx);
     }
+    const row = dispatchRow(action);
+    if (row) {
+      ctx.record = row;
+      ctx.recordId = row.id;
+    }
     return ctx;
   }
 
 
@@ -0,0 +1,85 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * A row action's `${ctx.*}` target holes read the row, the way the record
+ * header's do.
+ *
+ * The record header binds `record` in the runner's context (`RecordDetailView`'s
+ * `ActionProvider`, which also mirrors it under `ctx`). A list row binds nothing
+ * there: `ObjectGrid` dispatches a row action as
+ * `{ ...def, params: { _rowRecord: row } }` through the page's runner. The
+ * target interpolation read the runner's context only, so a `list_item` url
+ * action declared as `/apps/APP/OBJECT/record/${ctx.recordId}/page/P` landed
+ * on `/apps/APP/OBJECT/record/page/P` from a row menu.
+ *
+ * Each pin drives the SAME action through both doors:
+ *   - header — a runner whose context carries `record` (flat and in the `ctx`
+ *              mirror, as `ActionProvider` publishes it), dispatch without a row;
+ *   - row    — a runner whose context carries no `record` (a list page), the
+ *              dispatch carrying the row exactly as `ObjectGrid` stashes it.
+ */
+import { describe, it, expect, vi, type Mock } from 'vitest';
+import { ActionRunner, type ActionDef, type NavigationHandler } from '../ActionRunner';
+
+const ROW = { id: 'usr_1', name: 'Ada' };
+
+const OPEN_MEMBER: ActionDef = {
+  name: 'member_open',
+  objectName: 'sys_user',
+  type: 'url',
+  target: '/apps/app_x/sys_user/record/${ctx.recordId}/page/member',
+};
+
+/** `ActionProvider`'s context shape: the flat keys plus their `ctx` mirror. */
+const provided = (context: Record<string, unknown>) => new ActionRunner({ ...context, ctx: { ...context } });
+/** The record header. */
+const headerDoor = () => provided({ objectName: 'sys_user', record: { ...ROW } });
+/** A list page: the context names the object, not a record. */
+const listDoor = () => provided({ objectName: 'sys_user' });
+/** `ObjectGrid`'s row dispatch shape: the row under `params._rowRecord`. */
+const asRow = (def: ActionDef, row: Record<string, unknown> = ROW): ActionDef => ({ ...def, params: { _rowRecord: row } });
+
+async function navigatedTo(runner: ActionRunner, def: ActionDef): Promise<string> {
+  const nav: Mock<NavigationHandler> = vi.fn();
+  runner.setNavigationHandler(nav);
+  const result = await runner.execute(def);
+  expect(result.success).toBe(true);
+  expect(nav).toHaveBeenCalledTimes(1);
+  return nav.mock.calls[0][0];
+}
+
+describe('ActionRunner — a row action interpolates its target from the row', () => {
+  it('`${ctx.recordId}` reads the same id from the record header and from a list row', async () => {
+    expect(await navigatedTo(headerDoor(), OPEN_MEMBER)).toBe('/apps/app_x/sys_user/record/usr_1/page/member');
+    expect(await navigatedTo(listDoor(), asRow(OPEN_MEMBER))).toBe('/apps/app_x/sys_user/record/usr_1/page/member');
+  });
+
+  it('`${ctx.record.FIELD}` reads the row on a list page', async () => {
+    const def: ActionDef = { ...OPEN_MEMBER, target: '/people?id=${ctx.record.id}&name=${ctx.record.name}' };
+    expect(await navigatedTo(headerDoor(), def)).toBe('/people?id=usr_1&name=Ada');
+    expect(await navigatedTo(listDoor(), asRow(def))).toBe('/people?id=usr_1&name=Ada');
+  });
+
+  it('the row wins over a page-level record (a related-list row on a record page)', async () => {
+    const onParentPage = provided({ objectName: 'sys_org', record: { id: 'org_1', name: 'Parent' } });
+    const def: ActionDef = { ...OPEN_MEMBER, target: '/people/${ctx.recordId}?name=${ctx.record.name}' };
+    expect(await navigatedTo(onParentPage, asRow(def))).toBe('/people/usr_1?name=Ada');
+  });
+
+  it('`${ctx.selection.ids}` stays the checked selection, which a row dispatch does not fill', async () => {
+    const def: ActionDef = { ...OPEN_MEMBER, target: '/people?ids=${ctx.selection.ids}&count=${ctx.selection.count}' };
+    expect(await navigatedTo(listDoor(), asRow(def))).toBe('/people?ids=&count=0');
+    const checked = new ActionRunner({ objectName: 'sys_user', selectedRecords: [{ id: 'usr_2' }, { id: 'usr_3' }] });
+    expect(await navigatedTo(checked, asRow(def))).toBe('/people?ids=usr_2%2Cusr_3&count=2');
+  });
+
+  it('CONTROL: a dispatch with no row on a list page still reads no record', async () => {
+    expect(await navigatedTo(listDoor(), OPEN_MEMBER)).toBe('/apps/app_x/sys_user/record//page/member');
+  });
+});