@@ -12,6 +12,8 @@
 
 import { beforeEach, describe, expect, it } from 'vitest';
 import { AutomationEngine } from '../engine.js';
+import { InMemorySuspendedRunStore } from '../suspended-run-store.js';
+import { installBuiltinNodes } from './index.js';
 import { registerNotifyNode } from './notify-node.js';
 import type { MessagingServiceSurface } from './notify-node.js';
 import { FlowTextTemplateError, renderTextSlot } from './template.js';
@@ -108,6 +110,57 @@ describe('notify — a no-argument currency hole formats in the run organization
     });
 });
 
+describe('a run parked before run setup seeded a currency resumes in the organization\'s default', () => {
+    const PARKED = {
+        name: 'deal_review',
+        label: 'Deal Review',
+        type: 'screen' as const,
+        variables: [{ name: 'amount', type: 'number' as const, isInput: true }],
+        nodes: [
+            { id: 'start', type: 'start' as const, label: 'Start' },
+            { id: 'ask', type: 'screen' as const, label: 'Ask', config: { waitForInput: true, title: 'Confirm', fields: [{ name: 'ok', label: 'OK', type: 'checkbox' }] } },
+            { id: 'notify', type: 'notify' as const, label: 'Notify', config: { recipients: ['user_1'], title: 'Won {{ amount | currency }}', message: 'x' } },
+            { id: 'end', type: 'end' as const, label: 'End' },
+        ],
+        edges: [
+            { id: 'e1', source: 'start', target: 'ask' },
+            { id: 'e2', source: 'ask', target: 'notify' },
+            { id: 'e3', source: 'notify', target: 'end' },
+        ],
+    };
+
+    function engineOver(store: InMemorySuspendedRunStore, messaging: ReturnType<typeof fakeMessaging>) {
+        const engine = new AutomationEngine(createTestLogger(), store);
+        installBuiltinNodes(engine, {
+            logger: createTestLogger(),
+            getService: (name: string) => (name === 'messaging' ? messaging.service : undefined),
+        } as never);
+        engine.registerFlow('deal_review', PARKED);
+        return engine;
+    }
+
+    it('a cold resume seeds the default the persisted context lacks, and leaves the persisted context as it parked', async () => {
+        const store = new InMemorySuspendedRunStore();
+        const before = engineOver(store, fakeMessaging());
+        // Parked by an engine with no resolver: the persisted context carries no currency.
+        const paused = await before.execute('deal_review', { params: { amount: 1234.5 }, tenantId: 'org_cn' } as any);
+        expect(paused.status).toBe('paused');
+        const parked = await store.load(paused.runId!);
+        expect(parked?.context).not.toHaveProperty('currency');
+
+        const messaging = fakeMessaging();
+        const after = engineOver(store, messaging);
+        const reads: Array<string | undefined> = [];
+        after.setTenantCurrencyResolver((tenantId) => { reads.push(tenantId); return 'CNY'; });
+        const resumed = await after.resume(paused.runId!, { variables: { ok: true } } as never);
+
+        expect(resumed.success, JSON.stringify(resumed)).toBe(true);
+        expect(reads).toEqual(['org_cn']);
+        expect(messaging.emitted[0]?.payload).toMatchObject({ title: 'Won CN¥1,234.50' });
+        expect(parked?.context).not.toHaveProperty('currency');
+    });
+});
+
 describe('renderTextSlot — the tenant default on the engine\'s reserved channel', () => {
     const vars = new Map<string, unknown>([['amount', 1234.5], ['currency', 'EUR']]);
 
 
@@ -163,6 +163,40 @@ describe('#22450 — the authored message renders whenever no translation is pic
     });
 });
 
+describe('a refusal both texts share is the authored text\'s, and no line blames the translation', () => {
+    it('a no-argument `currency` hole with no tenant default fails the run naming the hole, with no translation warning', async () => {
+        const lines: LogLine[] = [];
+        const zh = { flows: { dedupe: { refusals: { finish: { message: '已拒绝:{{ record.amount | currency }}' } } } } };
+        const { engine } = engineWith(i18nWith({ 'zh-CN': zh }), lines);
+        const flow = refusingFlow();
+        (flow.nodes[1] as { config: { message: string } }).config.message = 'Refused: {{ record.amount | currency }}';
+        engine.registerFlow('dedupe', flow as never);
+
+        const result = await engine.execute('dedupe', {
+            ...doorContext('zh-CN'), record: { ...ACME, amount: 1234.5 },
+        } as unknown as AutomationContext);
+
+        expect(result.success).toBe(false);
+        expect(String(result.error)).toContain('{{ record.amount | currency }}');
+        expect(String(result.error)).toContain('localization.currency');
+        expect(lines.filter((l) => l.level === 'warn' && l.message.includes('translation'))).toEqual([]);
+    });
+
+    it('CONTROL — with the tenant default on the run, the zh-CN translation renders in it', async () => {
+        const zh = { flows: { dedupe: { refusals: { finish: { message: '已拒绝:{{ record.amount | currency }}' } } } } };
+        const { engine } = engineWith(i18nWith({ 'zh-CN': zh }));
+        const flow = refusingFlow();
+        (flow.nodes[1] as { config: { message: string } }).config.message = 'Refused: {{ record.amount | currency }}';
+        engine.registerFlow('dedupe', flow as never);
+
+        const result = await engine.execute('dedupe', {
+            ...doorContext('zh-CN'), record: { ...ACME, amount: 1234.5 }, currency: 'CNY',
+        } as unknown as AutomationContext);
+
+        expect(result.refusalMessage).toBe(`已拒绝:${new Intl.NumberFormat('en-US', { style: 'currency', currency: 'CNY' }).format(1234.5)}`);
+    });
+});
+
 describe('#22450 — a door-started run carries its locale into a resumed leg', () => {
     /** `start → ask (screen) → finish (refused)`: the refusal renders on the RESUMED leg. */
     function reviewFlow() {
 
@@ -5636,6 +5636,11 @@ export class AutomationEngine implements IAutomationService {
      * permission sets, so its data operations fall back to the baseline member
      * set — narrower, never the trigger user's grants (see the warning in
      * {@link seedRunGrants}).
+     *
+     * A segment whose persisted context carries no
+     * {@link AutomationContext.currency} — a run parked before run setup
+     * seeded one — is seeded here the way {@link resolveRunContext} seeds a
+     * new run, on a copy: the persisted `run.context` is left as it parked.
      */
     private resolveDecisionSegmentContext(
         run: SuspendedRun,
@@ -5644,6 +5649,7 @@ export class AutomationEngine implements IAutomationService {
         // The body lives in ./run-resume.ts (#25222).
         const host: ThisParameterType<typeof resolveDecisionSegmentContext> = {
             seedRunGrants: (...a) => this.seedRunGrants(...a),
+            tenantCurrencyResolver: this.tenantCurrencyResolver,
         };
         return resolveDecisionSegmentContext.call(host, run, signal);
     }
 
@@ -113,27 +113,36 @@ export function renderRefusalMessage(
     );
 }
 
-/** The body of {@link AutomationEngine.renderFlowTextSlot}, moved unedited; that method's docblock is its contract. */
+/** The body of {@link AutomationEngine.renderFlowTextSlot}; that method's docblock is its contract. */
 export function renderFlowTextSlot(
     this: Pick<NodeTextRenderingHost, 'translatedFlowTemplate' | 'logger'>,
     slot: FlowTextSlotTranslation,
     variables: Map<string, unknown>,
     context: AutomationContext,
 ): string | undefined {
     const translated = this.translatedFlowTemplate(slot, context.locale);
+    let translationRefusal: FlowTextTemplateError | undefined;
     if (translated !== undefined) {
         try {
             return renderTextSlot(translated.template, variables, context.currency);
         } catch (err: unknown) {
             if (!(err instanceof FlowTextTemplateError)) throw err;
-            this.logger.warn(
-                `[automation] ${slot.subject}: the '${translated.locale}' translation at '${slot.key}' does not ` +
-                `compile (${err.message}), so ${slot.shownAs} shows its authored text instead. Fix the ` +
-                `translation's holes to match the authored text.`,
-            );
+            translationRefusal = err;
         }
     }
-    return renderTextSlot(slot.authored, variables, context.currency);
+    // The authored text renders before the translation is blamed: when it
+    // throws too (a `{{ amount | currency }}` hole that meets no tenant
+    // default refuses both alike), its own refusal is the answer, and no line
+    // tells anyone to fix a translation that is not at fault.
+    const authored = renderTextSlot(slot.authored, variables, context.currency);
+    if (translated !== undefined && translationRefusal !== undefined) {
+        this.logger.warn(
+            `[automation] ${slot.subject}: the '${translated.locale}' translation at '${slot.key}' does not ` +
+            `compile (${translationRefusal.message}), so ${slot.shownAs} shows its authored text instead. Fix the ` +
+            `translation's holes to match the authored text.`,
+        );
+    }
+    return authored;
 }
 
 /** The body of {@link AutomationEngine.translatedFlowTemplate}, moved unedited; that method's docblock is its contract. */
 
@@ -262,8 +262,37 @@ export async function seedRunGrants(
     }
 }
 
-/** The body of {@link AutomationEngine.resolveDecisionSegmentContext}, moved unedited; that method's docblock is its contract. */
+/** The body of {@link AutomationEngine.resolveDecisionSegmentContext}; that method's docblock is its contract. */
 export async function resolveDecisionSegmentContext(
+    this: Pick<RunResumeHost, 'seedRunGrants' | 'tenantCurrencyResolver'>,
+    run: SuspendedRun,
+    signal: ResumeSignal,
+): Promise<AutomationContext> {
+    return withTenantCurrency.call(this, await deciderSegmentContext.call(this, run, signal));
+}
+
+/**
+ * A resumed segment's context with the organization's default currency, when
+ * the persisted one carries none: a run parked before run setup seeded
+ * `currency` would otherwise refuse a `{{ amount | currency }}` hole whose
+ * remedy, the setting, is already in place. A copy, never the persisted
+ * context; a failed or empty read leaves it as it was.
+ */
+async function withTenantCurrency(
+    this: Pick<RunResumeHost, 'tenantCurrencyResolver'>,
+    context: AutomationContext,
+): Promise<AutomationContext> {
+    if (context?.currency !== undefined || !this.tenantCurrencyResolver) return context;
+    try {
+        const currency = await this.tenantCurrencyResolver(context?.tenantId);
+        if (typeof currency === 'string' && currency !== '') return { ...(context ?? {}), currency } as AutomationContext;
+    } catch {
+        // Tolerated, as at run setup: the hole's own refusal is the loud answer.
+    }
+    return context;
+}
+
+async function deciderSegmentContext(
     this: Pick<RunResumeHost, 'seedRunGrants'>,
     run: SuspendedRun,
     signal: ResumeSignal,
 
@@ -46,6 +46,23 @@ describe('fillTemplateHoles: a no-argument currency hole reads the tenant defaul
     expect(fillTemplateHoles(source, { amount: AMOUNT }, 'en-US')).toBe(source);
   });
 
+  it('a refused sentence logs the refusal, naming the hole and the remedy, once', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      const source = 'Logged {{ amount | currency }}?';
+      expect(fillTemplateHoles(source, { amount: AMOUNT }, 'en-US')).toBe(source);
+      expect(fillTemplateHoles(source, { amount: AMOUNT }, 'en-US')).toBe(source);
+      expect(warn).toHaveBeenCalledTimes(1);
+      const line = String(warn.mock.calls[0][0]);
+      expect(line).toContain(source);
+      expect(line).toContain('{{ amount | currency }}');
+      expect(line).toContain('localization.currency');
+      expect(line).toContain('currency:EUR');
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
   it('a hole that names its code needs no tenant default', () => {
     expect(fillTemplateHoles('{{ amount | currency:EUR }}', { amount: AMOUNT }, 'en-US')).toBe(money('en-US', 'EUR'));
   });
 
@@ -90,6 +90,12 @@ export function hasTemplateHoles(text: string): boolean {
  * channel: a `{{ amount | currency }}` hole with no argument formats in it.
  * Omitted, the engine refuses such a sentence and it is returned as written,
  * like any sentence the engine refuses — never with a guessed currency.
+ *
+ * A refused sentence is shown as written, and the engine's refusal — which
+ * names the hole and the remedy (for a missing default: set
+ * `localization.currency`, or write `currency:CODE`) — goes to
+ * `console.warn`, once per distinct refusal, so it reaches whoever reads the
+ * console rather than nobody.
  */
 export function fillTemplateHoles(
   source: string,
@@ -101,5 +107,18 @@ export function fillTemplateHoles(
     { dialect: 'template', source },
     { extra: roots, locale, ...(currency ? { currency } : {}) },
   );
-  return filled.ok && typeof filled.value === 'string' ? filled.value : source;
+  if (filled.ok && typeof filled.value === 'string') return filled.value;
+  if (!filled.ok) warnRefusedCopy(source, filled.error.message);
+  return source;
+}
+
+/** Refusals already logged, so a dialog that re-renders does not repeat one. */
+const warnedRefusals = new Set<string>();
+
+function warnRefusedCopy(source: string, refusal: string): void {
+  const key = `${source}\u0000${refusal}`;
+  if (warnedRefusals.has(key)) return;
+  if (warnedRefusals.size >= 200) warnedRefusals.clear();
+  warnedRefusals.add(key);
+  console.warn(`[action copy] the sentence "${source}" is shown as written: ${refusal}`);
 }