@@ -0,0 +1,14 @@
+---
+'@objectstack/runtime': patch
+---
+
+feat(runtime): the flow and permission-set "New similar" answers name their notice by a stable `noticeCode`
+
+Clause-②: no
+Metadata-protocol: none
+
+Both clone doors answered with an English `notice` and nothing that named it, so a console could only print the sentence verbatim, and a zh-CN screen showed English. Each answer now also carries `noticeCode` beside the unchanged `notice`, so a console can map a code it knows to its own translated sentence and fall back to `notice` for a code it does not know.
+
+- **Flow clone** (`POST /api/v1/automation/:name/clone`): `data.noticeCode` is `FLOW_CLONE_DISABLED_COPY` (exported as `FLOW_CLONE_NOTICE_CODE` beside `FLOW_CLONE_NOTICE`), the key `CloneFlowResponseSchema` already declares.
+- **Permission-set clone** (`POST /api/v1/security/permission-sets/:name/clone`): one code per notice variant, `PERMISSION_SET_CLONE_ENVIRONMENT_WIDE`, `PERMISSION_SET_CLONE_IN_PACKAGE` or `PERMISSION_SET_CLONE_IN_CREATED_PACKAGE`. The one value the sentence carries, the package, is already on the answer as `data.package`, so no parameter key is needed. Code and sentence are chosen from the same landing kind (`PERMISSION_SET_CLONE_NOTICE_CODES`, `permissionSetCloneNoticeCode`), so they cannot drift.
+- **`notice` is unchanged**, byte for byte, and stays the English fallback.
@@ -460,8 +460,9 @@ the source never reach the copy.
   (`packageId`, `protection` and the internal protection envelope),
   and two privilege decisions — `adminScope` (delegated administration) and
   `isDefault` (the `everyone` suggestion). Grant either deliberately on the copy
-  if it needs one. The response, `{ permissionSet, package, notice }`, says
-  where the copy went and what was not copied.
+  if it needs one. The response, `{ permissionSet, package, notice, noticeCode }`, says
+  where the copy went and what was not copied. `noticeCode` names the notice's
+  variant so a console can translate it, and `notice` stays the English fallback.
 - **The copy is held by nobody** until you add it to a position or assign it.
 - **Who may call it** is who may save a permission set through the metadata
   API: a holder of `manage_metadata`. Anyone else is refused `403`
 
@@ -38,7 +38,7 @@ import { bootStack, type VerifyStack } from '@objectstack/verify';
 
 // Read from the implementation rather than restated: the notice is a contract
 // value, and a second spelling of it would agree only until one of them moves.
-import { FLOW_CLONE_NOTICE } from '../../../runtime/src/flow-clone.js';
+import { FLOW_CLONE_NOTICE, FLOW_CLONE_NOTICE_CODE } from '../../../runtime/src/flow-clone.js';
 
 /** The CRM app's own shipped flow — a real definition, not one this test injects. */
 const SOURCE = 'crm_convert_lead_wizard';
@@ -92,10 +92,12 @@ describe('#20676 — POST /automation/:name/clone is mounted on the dispatcher b
     expect(res.status, `legal clone: ${text}`).toBe(200);
     const body = (await res.json()) as {
       success?: boolean;
-      data?: { flow?: { name?: string; label?: string; status?: string }; packageId?: string; notice?: string };
+      data?: { flow?: { name?: string; label?: string; status?: string }; packageId?: string; notice?: string; noticeCode?: string };
     };
     expect(body.success).toBe(true);
     expect(body.data?.notice).toBe(FLOW_CLONE_NOTICE);
+    // [#29727] The notice is named by its code, for a console that translates it.
+    expect(body.data?.noticeCode).toBe(FLOW_CLONE_NOTICE_CODE);
     // [#28149, ADR-0146 D4] "New similar": switched off, in the CRM's paired
     // customization package, which the clone ensured on first use.
     expect(body.data?.flow).toMatchObject({ name: CLONE, label: CLONE_LABEL, status: 'obsolete' });
 
@@ -104,7 +104,9 @@ describe('the permission-set clone door, on a booted showcase', () => {
         const res = await clone(token, DELEGATE_SET, { name: DELEGATE_COPY, label: 'My Field Ops Delegate' });
         const text = await res.clone().text();
         expect(res.status, text).toBe(200);
-        const data = JSON.parse(text).data as { permissionSet: Record<string, unknown>; package: string | null; notice: string };
+        const data = JSON.parse(text).data as {
+            permissionSet: Record<string, unknown>; package: string | null; notice: string; noticeCode?: string;
+        };
         expect(data.permissionSet.name).toBe(DELEGATE_COPY);
         expect(data.permissionSet).not.toHaveProperty('adminScope');
         expect(data.permissionSet).not.toHaveProperty('packageId');
@@ -113,6 +115,8 @@ describe('the permission-set clone door, on a booted showcase', () => {
         // ensure door created for it.
         expect(data.package).toBe(SHOWCASE_PAIR);
         expect(data.notice).toContain(`'${SHOWCASE_PAIR}'`);
+        // [#29727] The notice is named by its variant's code: a pair created for this copy.
+        expect(data.noticeCode).toBe('PERMISSION_SET_CLONE_IN_CREATED_PACKAGE');
         const pair = await stack.apiAs(token, 'GET', `/packages/${SHOWCASE_PAIR}`);
         expect(pair.status, await pair.clone().text()).toBe(200);
 
@@ -139,7 +143,10 @@ describe('the permission-set clone door, on a booted showcase', () => {
         const res = await clone(token, DEFAULT_SET, { name: DEFAULT_COPY, label: 'My Member Default' });
         expect(res.status, await res.clone().text()).toBe(200);
         // The second copy REUSES the pair the first created: one pair, the same id.
-        expect(((await res.json()) as any).data.package).toBe(SHOWCASE_PAIR);
+        const reused = ((await res.json()) as any).data;
+        expect(reused.package).toBe(SHOWCASE_PAIR);
+        // [#29727] Reused, not created: the in-package code.
+        expect(reused.noticeCode).toBe('PERMISSION_SET_CLONE_IN_PACKAGE');
         const listed = ((await (await stack.apiAs(token, 'GET', '/packages')).json()) as any).data;
         const pairs = (Array.isArray(listed) ? listed : listed?.packages ?? [])
             .filter((p: any) => (p?.manifest?.id ?? p?.id) === SHOWCASE_PAIR);
 
@@ -46,7 +46,7 @@ import { FlowSchema } from '@objectstack/spec/automation';
 import { ROUTE_LEDGER } from '../route-ledger.js';
 import { HttpDispatcher } from '../http-dispatcher.js';
 import { validationFailureDetails, VALIDATION_FAILED_STATUS } from '../validation-failure.js';
-import { FLOW_CLONE_NOTICE, FLOW_CLONE_STATUS } from '../flow-clone.js';
+import { FLOW_CLONE_NOTICE, FLOW_CLONE_NOTICE_CODE, FLOW_CLONE_STATUS } from '../flow-clone.js';
 
 let home: string;
 let priorHome: string | undefined;
@@ -214,6 +214,9 @@ describe('[#28149] the default target: the copy lands in <base>.custom, switched
         expect(row.item.status).toBe('obsolete');
         expect(rig.flows.get('acme_lead_followup')?.status).toBe('obsolete');
         expect(answer.data.notice).toBe(FLOW_CLONE_NOTICE);
+        // [#29727] …named by its code, which the declared answer carries.
+        expect(answer.data.noticeCode).toBe(FLOW_CLONE_NOTICE_CODE);
+        expect(CloneFlowResponseSchema.parse(answer.body).data.noticeCode).toBe(FLOW_CLONE_NOTICE_CODE);
         // …and the original keeps running, untouched.
         expect(rig.flows.get(SOURCE)?.status).toBe('active');
         expect(await rig.rows(SOURCE)).toEqual([]);
 
@@ -50,6 +50,7 @@ import {
     FLOW_CLONE_MUTATED_FIELDS,
     FLOW_CLONE_NAME_TAKEN_STATUS,
     FLOW_CLONE_NOTICE,
+    FLOW_CLONE_NOTICE_CODE,
     FLOW_CLONE_STATUS,
 } from '../flow-clone.js';
 
@@ -502,6 +503,27 @@ describe('#12156 — the source, the notice, and the gate', () => {
         expect(notice).not.toMatch(/\b(draft|status|off-switch|lifecycle|Studio)\b/i);
     });
 
+    it('[#29727] names the notice by a stable code beside it, and the notice stays byte-identical', async () => {
+        // A console shows the notice in its own language by mapping the code;
+        // `notice` stays the English fallback for a code it does not know.
+        const source = packagedExemplar();
+        const { dispatcher } = makeDispatcher([source]);
+
+        const result = await dispatcher.handleAutomation(clonePath(source.name as string), 'POST', NEW, CTX);
+        const data = (result.response?.body?.data ?? {}) as Record<string, unknown>;
+
+        expect(result.response?.status).toBe(200);
+        expect(FLOW_CLONE_NOTICE_CODE).toBe('FLOW_CLONE_DISABLED_COPY');
+        expect(data.noticeCode).toBe(FLOW_CLONE_NOTICE_CODE);
+        // CONTROL: the English sentence is exactly the one served before the
+        // code arrived, spelled out here rather than read off the constant.
+        expect(data.notice).toBe(
+            'The copy is switched off and does not run until you switch it on, '
+            + 'and it still uses the same subflows, actions and objects as the original.',
+        );
+        expect(Object.keys(data).sort()).toEqual(['flow', 'notice', 'noticeCode', 'packageId']);
+    });
+
     it('is admin copy: it names controls, never an endpoint or a request body', async () => {
         // The console shows this notice verbatim on the clone result. The REST
         // recipe for the same switch is developer copy, in the client SDK.
 
@@ -81,6 +81,7 @@ import {
     flowCloneNameTakenMessage,
     FLOW_CLONE_NAME_TAKEN_STATUS,
     FLOW_CLONE_NOTICE,
+    FLOW_CLONE_NOTICE_CODE,
 } from '../flow-clone.js';
 // [#28149, ADR-0146 D4] The clone body's declaration (its closed member set)
 // and the target rule every "new similar" door shares.
@@ -3964,9 +3965,16 @@ export async function handleAutomationRequest(deps: DomainHandlerDeps, path: str
                 // opens the copy where it lives (Setup's "Open the clone in
                 // Studio"): the package is where the copy is, not where it
                 // came from, so it records no lineage.
+                // [#29727] `noticeCode` names the notice so a console can show
+                // it translated; `notice` stays the English fallback.
                 return {
                     handled: true,
-                    response: deps.success({ flow: servedFlowDefinition(clone), packageId: written.packageId, notice: FLOW_CLONE_NOTICE }),
+                    response: deps.success({
+                        flow: servedFlowDefinition(clone),
+                        packageId: written.packageId,
+                        notice: FLOW_CLONE_NOTICE,
+                        noticeCode: FLOW_CLONE_NOTICE_CODE,
+                    }),
                 };
             }
         }
 
@@ -31,7 +31,9 @@ import {
     PERMISSION_SET_CLONE_MUTATED_FIELDS,
     PERMISSION_SET_CLONE_NOTICE,
     clonePermissionSetDefinition,
+    PERMISSION_SET_CLONE_NOTICE_CODES,
     permissionSetCloneNotice,
+    permissionSetCloneNoticeCode,
     permissionSetObjectNames,
 } from './permission-set-clone.js';
 
@@ -197,6 +199,7 @@ describe('the permission-set clone door — success', () => {
             permissionSet: save.item,
             package: 'crm.custom',
             notice: permissionSetCloneNotice({ packageId: 'crm.custom', created: true }),
+            noticeCode: 'PERMISSION_SET_CLONE_IN_CREATED_PACKAGE',
         });
         expect(data.notice).toContain("'crm.custom'");
         expect(data.notice.endsWith(PERMISSION_SET_CLONE_NOTICE)).toBe(true);
@@ -212,6 +215,8 @@ describe('the permission-set clone door — success', () => {
         expect(statusOf(second)).toBe(200);
         expect(h.saves.map((s) => s.packageId)).toEqual(['crm.custom', 'crm.custom']);
         expect((second as any).response.body.data.notice).toBe(permissionSetCloneNotice({ packageId: 'crm.custom', created: false }));
+        // [#29727] Reused, not created: the in-package code, not the created one.
+        expect((second as any).response.body.data.noticeCode).toBe('PERMISSION_SET_CLONE_IN_PACKAGE');
     });
 
     it('CONTROL — an environment-authored set copies environment-wide, as before: no package, no ensure', async () => {
@@ -224,6 +229,9 @@ describe('the permission-set clone door — success', () => {
         expect(Object.keys(h.saves[0]).sort()).toEqual(['item', 'name', 'parentVersion', 'type']);
         expect(h.ensures).toEqual([]);
         expect((res as any).response.body.data.package).toBeNull();
+        // [#29727] The environment-wide variant's code.
+        expect((res as any).response.body.data.noticeCode).toBe('PERMISSION_SET_CLONE_ENVIRONMENT_WIDE');
+        expect((res as any).response.body.data.notice).toBe(permissionSetCloneNotice({ packageId: null, created: false }));
     });
 
     it('a set already in a writable package copies into that package, with no ensure', async () => {
@@ -235,6 +243,8 @@ describe('the permission-set clone door — success', () => {
         expect(h.saves[0].packageId).toBe('com.acme.base');
         expect(h.saves[0].item).not.toHaveProperty('_packageId');
         expect(h.ensures).toEqual([]);
+        // [#29727] The in-package variant's code.
+        expect((res as any).response.body.data.noticeCode).toBe('PERMISSION_SET_CLONE_IN_PACKAGE');
     });
 
     it('a given writable target that reaches the set lands there, with no ensure', async () => {
@@ -316,6 +326,45 @@ describe('the permission-set clone door — authority', () => {
     });
 });
 
+describe('[#29727] the clone notice is named by one stable code per landing', () => {
+    // CONTROL: the three sentences, spelled out as they were served before the
+    // codes arrived, so a change to `notice` while adding a code reds here.
+    const TAIL =
+        'The copy is a new permission set authored in this system, with no link to the set it was copied '
+        + 'from: changes to that set do not reach it. Not copied: delegated-admin scope (`adminScope`) and the '
+        + 'everyone-baseline suggestion (`isDefault`) \u2014 grant either deliberately on the copy if it needs one. '
+        + 'The copy is held by nobody yet: add it to a position, or assign it to users.';
+    const VARIANTS = [
+        {
+            landing: { packageId: null, created: false },
+            code: 'PERMISSION_SET_CLONE_ENVIRONMENT_WIDE',
+            notice: 'The copy was saved environment-wide, in no package, as the set it was copied from is. ' + TAIL,
+        },
+        {
+            landing: { packageId: 'com.acme.base', created: false },
+            code: 'PERMISSION_SET_CLONE_IN_PACKAGE',
+            notice: "The copy was saved in package 'com.acme.base', beside the original rather than in place of it, "
+                + 'and travels with that package. ' + TAIL,
+        },
+        {
+            landing: { packageId: 'crm.custom', created: true },
+            code: 'PERMISSION_SET_CLONE_IN_CREATED_PACKAGE',
+            notice: "The copy was saved in package 'crm.custom', created for it to hold your changes to the package "
+                + 'the set came from, beside the original rather than in place of it, and travels with that package. ' + TAIL,
+        },
+    ] as const;
+
+    it.each(VARIANTS)('$code names its sentence, and the sentence is byte-identical', ({ landing, code, notice }) => {
+        expect(permissionSetCloneNoticeCode(landing)).toBe(code);
+        expect(permissionSetCloneNotice(landing)).toBe(notice);
+    });
+
+    it('the three codes are distinct and the table holds exactly them', () => {
+        expect(Object.values(PERMISSION_SET_CLONE_NOTICE_CODES).sort()).toEqual(VARIANTS.map((v) => v.code).sort());
+        expect(new Set(VARIANTS.map((v) => permissionSetCloneNotice(v.landing))).size).toBe(3);
+    });
+});
+
 describe('the permission-set clone door — refusals', () => {
     const refusal = async (opts: BootOptions, source: string, body: unknown, status: number, code: string) => {
         const h = boot(opts);
 
@@ -86,7 +86,8 @@
  *    not a package for every set.
  *
  * The response names the package (`package`, `null` for environment-wide) and
- * the notice says where the copy went ({@link permissionSetCloneNotice}).
+ * the notice says where the copy went ({@link permissionSetCloneNotice}), named
+ * by a stable code beside it ({@link permissionSetCloneNoticeCode}).
  *
  * ## Authority
  *
@@ -159,21 +160,53 @@ export interface PermissionSetCloneLanding {
     readonly created: boolean;
 }
 
+/**
+ * [#29727] The stable code for each notice variant, served beside the notice
+ * as `data.noticeCode`. One code per landing, so a console can show the
+ * sentence in its own language without a parameter key: the one value the
+ * sentence carries, the package, is already on the answer as `data.package`.
+ * A console maps a code it knows to its own sentence and falls back to
+ * `notice` verbatim for a code it does not know; `notice` stays the English
+ * fallback. Keyed by {@link PermissionSetCloneLandingKind}, the same key
+ * {@link permissionSetCloneNotice} composes its sentence from, so code and
+ * sentence cannot drift.
+ */
+export const PERMISSION_SET_CLONE_NOTICE_CODES = Object.freeze({
+    environmentWide: 'PERMISSION_SET_CLONE_ENVIRONMENT_WIDE',
+    inPackage: 'PERMISSION_SET_CLONE_IN_PACKAGE',
+    inCreatedPackage: 'PERMISSION_SET_CLONE_IN_CREATED_PACKAGE',
+} as const);
+
+/** Which of the three notices a landing is told with. */
+export type PermissionSetCloneLandingKind = keyof typeof PERMISSION_SET_CLONE_NOTICE_CODES;
+
+/** The one place a landing is sorted into its notice variant. */
+export function permissionSetCloneLandingKind(landing: PermissionSetCloneLanding): PermissionSetCloneLandingKind {
+    if (landing.packageId === null) return 'environmentWide';
+    return landing.created ? 'inCreatedPackage' : 'inPackage';
+}
+
 /**
  * The notice for one landing: where the copy went, in the server's words,
  * ahead of {@link PERMISSION_SET_CLONE_NOTICE}.
  */
 export function permissionSetCloneNotice(landing: PermissionSetCloneLanding): string {
-    if (landing.packageId === null) {
+    const kind = permissionSetCloneLandingKind(landing);
+    if (kind === 'environmentWide') {
         return 'The copy was saved environment-wide, in no package, as the set it was copied from is. '
             + PERMISSION_SET_CLONE_NOTICE;
     }
     return `The copy was saved in package '${landing.packageId}'`
-        + (landing.created ? ', created for it to hold your changes to the package the set came from' : '')
+        + (kind === 'inCreatedPackage' ? ', created for it to hold your changes to the package the set came from' : '')
         + ', beside the original rather than in place of it, and travels with that package. '
         + PERMISSION_SET_CLONE_NOTICE;
 }
 
+/** The code naming {@link permissionSetCloneNotice}'s sentence for the same landing. */
+export function permissionSetCloneNoticeCode(landing: PermissionSetCloneLanding): string {
+    return PERMISSION_SET_CLONE_NOTICE_CODES[permissionSetCloneLandingKind(landing)];
+}
+
 /** ADR-0112 status for a target name the catalog already holds. */
 export const PERMISSION_SET_CLONE_NAME_TAKEN_STATUS = 409;
 
@@ -529,6 +562,8 @@ export async function handlePermissionSetCloneWrite(
                 permissionSet: clone,
                 package: landing.packageId,
                 notice: permissionSetCloneNotice(landing),
+                // [#29727] The notice's code, for a console that translates it.
+                noticeCode: permissionSetCloneNoticeCode(landing),
             }),
         };
     } catch (err: unknown) {
 
@@ -207,6 +207,18 @@ export const FLOW_CLONE_NOTICE =
     'The copy is switched off and does not run until you switch it on, '
     + 'and it still uses the same subflows, actions and objects as the original.';
 
+/**
+ * The stable code naming {@link FLOW_CLONE_NOTICE}, served beside it as
+ * `data.noticeCode` (`CloneFlowResponseSchema`, #29758).
+ *
+ * [#29727] A console shows the notice in its own language by mapping this code
+ * to its own translated sentence, and falls back to `notice` verbatim for a
+ * code it does not know. The code names the SENTENCE, so it changes only when
+ * the sentence's meaning does; `notice` stays the English fallback, unchanged.
+ * It lives beside the sentence so the two are edited together.
+ */
+export const FLOW_CLONE_NOTICE_CODE = 'FLOW_CLONE_DISABLED_COPY' as const;
+
 /** ADR-0112 envelope for the same-name refusal: a status AND a code. */
 export const FLOW_CLONE_NAME_TAKEN_STATUS = 409;