@@ -366,30 +366,6 @@ describe('executeMaestroProgram', () => {
     );
   });
 
-  test('optional-skip warnings append the failure hint', async () => {
-    const execute = vi.fn(async (request: MaestroRuntimeRequest) => {
-      request.invalidateObservation();
-      throw maestroTestFailure('Maestro target did not resolve to a visible element.', {
-        hint: 'Regular presentation requires valid viewport evidence.',
-      });
-    });
-    const port = makePort({
-      observe: vi.fn(async ({ generation }) => ({ generation, matched: false })),
-      execute,
-    });
-    const program = parseMaestroProgram(
-      ['---', '- tapOn:', '    text: Missing target', '    optional: true'].join('\n'),
-    );
-
-    const result = await executeMaestroProgram(program, port);
-
-    expect(result.warnings).toEqual([
-      expect.stringMatching(
-        /Optional Maestro tapOn skipped at line 2: .*\(Regular presentation requires valid viewport evidence\.\)/,
-      ),
-    ]);
-  });
-
   test('observer failure cannot mask nested leaf failure provenance', async () => {
     const execute = vi.fn(async (request: MaestroRuntimeRequest) => {
       request.invalidateObservation();
 
@@ -99,13 +99,8 @@ async function executeOptionalCommand(
 
 function formatOptionalWarning(command: MaestroRuntimeCommand, error: unknown): string {
   const source = `${command.source.path ? `${command.source.path}:` : ''}line ${command.source.line}`;
-  const detail =
-    error instanceof AppError
-      ? typeof error.details?.hint === 'string'
-        ? `${error.message} (${error.details.hint})`
-        : error.message
-      : String(error);
-  return `Optional Maestro ${command.kind} skipped at ${source}: ${detail}`;
+  const message = error instanceof AppError ? error.message : String(error);
+  return `Optional Maestro ${command.kind} skipped at ${source}: ${message}`;
 }
 
 function isOptionalCommand(command: MaestroRuntimeCommand): boolean {
 
@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { expect, test } from 'vitest';
+import { runReplayTestCase } from '../session-test-attempt.ts';
+import type { ReplayTestRunEntry } from '../session-test-discovery.ts';
+import type { ReplayTestAttemptOutcome } from '../session-test-types.ts';
+import type { ReplaySuiteTestFailed } from '@agent-device/contracts/replay';
+
+const FAILED_WITH_WARNINGS: ReplayTestAttemptOutcome = {
+  status: 'failed',
+  error: {
+    code: 'REPLAY_DIVERGENCE',
+    message: 'Replay failed at step 2 (tapOn "Save"): target did not resolve',
+  },
+  artifactPaths: [],
+  warnings: ['Optional Maestro assertVisible skipped at line 3: sheet owns focus'],
+  infrastructure: false,
+};
+
+const FAILED_WITHOUT_WARNINGS: ReplayTestAttemptOutcome = {
+  status: 'failed',
+  error: { code: 'COMMAND_FAILED', message: 'tap failed' },
+  artifactPaths: [],
+  infrastructure: false,
+};
+
+function makeEntry(): ReplayTestRunEntry {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-test-attempt-'));
+  const filePath = path.join(root, '01-flow.ad');
+  fs.writeFileSync(filePath, 'context platform=ios\nopen "Demo"\n');
+  return {
+    kind: 'run',
+    path: filePath,
+    title: 'flow',
+    manifest: { device: { platform: { kind: 'declared', value: 'ios' } } },
+  };
+}
+
+async function runFailedCase(outcome: ReplayTestAttemptOutcome): Promise<ReplaySuiteTestFailed> {
+  const report = await runReplayTestCase({
+    entry: makeEntry(),
+    sessionName: 'default',
+    suiteInvocationId: 'suite-attempt',
+    caseIndex: 0,
+    retries: 0,
+    suiteArtifactsDir: fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-test-attempt-suite-')),
+    suiteIndex: 1,
+    suiteTotal: 1,
+    runReplay: async () => outcome,
+    cleanupSession: async () => {},
+    emitProgress: () => {},
+    isCanceled: () => false,
+    emitDiagnostic: () => {},
+    bindAttemptCancellation: () => ({ cancel: () => {}, release: () => {} }),
+  });
+  if (report.result.status !== 'failed') throw new Error('expected a failed test result');
+  return report.result;
+}
+
+test('a failed test result carries the warnings accumulated before the failure (#2560)', async () => {
+  const result = await runFailedCase(FAILED_WITH_WARNINGS);
+  expect(result.warnings).toEqual([
+    'Optional Maestro assertVisible skipped at line 3: sheet owns focus',
+  ]);
+});
+
+test('a failed test result omits warnings when the attempt had none', async () => {
+  const result = await runFailedCase(FAILED_WITHOUT_WARNINGS);
+  expect('warnings' in result).toBe(false);
+});
@@ -388,8 +388,8 @@ function buildReplayTestFailedResult(
     attempts: outcome.attempts,
     artifactsDir: context.testArtifactsDir,
     error,
-    ...(attemptOutcome?.status === 'failed' && attemptOutcome.warnings
-      ? { warnings: [...attemptOutcome.warnings] }
+    ...(attemptOutcome?.status === 'failed' && (attemptOutcome.warnings?.length ?? 0) > 0
+      ? { warnings: [...attemptOutcome.warnings!] }
       : {}),
     ...(attemptOutcome?.status === 'failed' && attemptOutcome.infrastructure
       ? { infrastructure: true as const }
 
@@ -80,6 +80,38 @@ test('buildReplayJunitXml escapes tricky failure title/message and round-trips t
   assert.ok(failure.text?.startsWith(TRICKY_MESSAGE));
 });
 
+test('buildReplayJunitXml carries accumulated warnings of a failed test into system-out (#2560)', () => {
+  const suite: ReplaySuiteResult = {
+    total: 1,
+    executed: 1,
+    passed: 0,
+    failed: 1,
+    skipped: 0,
+    notRun: 0,
+    durationMs: 1200,
+    failures: [],
+    tests: [
+      {
+        file: '/tmp/flows/login.yaml',
+        title: 'sign-in',
+        session: 'default',
+        status: 'failed',
+        durationMs: 1200,
+        attempts: 1,
+        warnings: ['Optional Maestro assertVisible skipped at line 3: sheet owns focus'],
+        error: { code: 'COMMAND_FAILED', message: 'tapOn Save did not resolve' },
+      },
+    ],
+  };
+  suite.failures = suite.tests.filter((result) => result.status === 'failed');
+
+  const nodes = writeSuiteAndParse(suite);
+  const testcase = findChild(findChild(nodes[0]!, 'testsuite')!, 'testcase');
+  assert.ok(testcase);
+  const systemOut = findChild(testcase, 'system-out');
+  assert.ok(systemOut?.text?.includes('warning: Optional Maestro assertVisible skipped at line 3'));
+});
+
 test('buildReplayJunitXml escapes tricky skip message', () => {
   const suite: ReplaySuiteResult = {
     total: 1,
 
@@ -76,6 +76,31 @@ test('printHumanError renders a compact divergence report unconditionally (not g
   // Not gated behind --debug: showDetails defaults to false/undefined here.
 });
 
+// --- #2560: run-level warnings ride the failed response to the human surface ---
+
+test('printHumanError renders run-level warnings carried in error details', async () => {
+  const err = new AppError('REPLAY_DIVERGENCE', 'Replay failed at step 2 (tapOn "Save")', {
+    step: 2,
+    warnings: ['Optional Maestro assertVisible skipped at line 1: no match', 7],
+  });
+
+  const output = await captureStderr(() => printHumanError(err));
+
+  assert.match(
+    output,
+    /Error \(REPLAY_DIVERGENCE\)[\s\S]*^Warning: Optional Maestro assertVisible skipped at line 1: no match$/m,
+  );
+  assert.equal(output.includes('Warning: 7'), false);
+});
+
+test('printHumanError prints no Warning lines without a warnings channel', async () => {
+  const err = new AppError('COMMAND_FAILED', 'tap failed');
+
+  const output = await captureStderr(() => printHumanError(err));
+
+  assert.equal(output.includes('Warning:'), false);
+});
+
 // --- #1597: AMBIGUOUS_MATCH candidates print unconditionally, capped at 5 ---
 
 test('printHumanError lists AMBIGUOUS_MATCH candidates unconditionally, not gated behind --debug', async () => {
 
@@ -6,6 +6,7 @@ import {
   type NormalizedError,
 } from '@agent-device/kernel/errors';
 import { formatReplayDivergenceReport } from '@agent-device/ad-replay/divergence';
+import { collapseWarningText } from '../output-common.ts';
 
 export function printHumanError(
   err: AppError | NormalizedError,
@@ -20,6 +21,12 @@ export function printHumanError(
   if (normalized.hint) {
     process.stderr.write(`Hint: ${normalized.hint}\n`);
   }
+  // Composable warnings (skipped `optional` steps, capture degradations) describe the run,
+  // not this step's cause, so they ride at error level and must reach the reader of a
+  // failed run too — a warning-only trace is otherwise invisible outside --json (#2560).
+  for (const warning of readResponseWarnings(normalized.details)) {
+    process.stderr.write(`Warning: ${collapseWarningText(warning)}\n`);
+  }
   const candidateLines = formatErrorCandidateViews(readErrorCandidateViews(normalized.details));
   if (candidateLines.length > 0) {
     process.stderr.write(`${candidateLines.join('\n')}\n`);
@@ -47,6 +54,13 @@ export function printHumanError(
   }
 }
 
+function readResponseWarnings(details: Record<string, unknown> | undefined): string[] {
+  const warnings = details?.warnings;
+  return Array.isArray(warnings)
+    ? warnings.filter((warning): warning is string => typeof warning === 'string')
+    : [];
+}
+
 function formatErrorCandidateViews(views: ErrorCandidateView[]): string[] {
   return views.flatMap((view) => {
     if (view.kind === 'element-match') {
 
@@ -96,11 +96,9 @@ test('typed Maestro failure response carries warnings accumulated before the fai
     { warnings: ['Optional Maestro assertVisible skipped at line 2: no match'] },
   );
 
+  if (!response.error.details) throw new Error('expected error details on the failure response');
   const details = response.error.details;
-  expect(details).toBeDefined();
-  expect(details.warnings).toEqual([
-    'Optional Maestro assertVisible skipped at line 2: no match',
-  ]);
+  expect(details.warnings).toEqual(['Optional Maestro assertVisible skipped at line 2: no match']);
   expect((details.divergence as { kind: string }).kind).toBe('action-failure');
 });
 
 
@@ -104,7 +104,9 @@ export function buildReplayDivergenceFailureResponseFromDescriptor(params: {
         positionals,
         artifactPaths,
         ...(snapshotDiagnostics ? { snapshotDiagnostics } : {}),
-        ...(warnings && warnings.length > 0 ? { warnings: [...warnings] } : {}),
+        ...(warnings && warnings.length > 0
+          ? { warnings: warnings.map((warning) => scrubReplayVarValues(warning, scrubVars)) }
+          : {}),
         divergence,
       },
     },
 
@@ -123,7 +123,7 @@ agent-device test ./workflows --reporter default --reporter junit:./tmp/junit.xm
 - `replay-timing.ndjson` records attempt, cleanup, and per-step start/stop events with durations. Upload it from CI even for passing runs when comparing local and CI performance.
 - Timeouts are cooperative: the runner marks the attempt failed at the timeout boundary, then gives the underlying replay a short grace period to stop before session cleanup.
 - The default text reporter streams live progress on stderr while a suite runs, then prints the final summary, failed tests, and passed-on-retry flaky tests. Use `--verbose` to include step traces in completed-test progress output.
-- The default reporter prints a `Warnings:` section after the summary when any test accumulated composable warnings — for example a Maestro step with `optional: true` that was skipped — whether that test passed or failed. `--json` carries the same strings in each test result's `warnings` array.
+- The default reporter prints a `Warnings:` section after the summary when any test accumulated composable warnings — for example a Maestro step with `optional: true` that was skipped — whether that test passed or failed. A failing `replay` run repeats the warnings it accumulated as `Warning:` lines after the error. `--json` carries the same strings in each test result's `warnings` array.
 - `--reporter` is repeatable. Built-ins are `default` for the console summary and `junit:<path>` for JUnit XML. Passing any explicit reporter list replaces the implicit default reporter, so include `--reporter default` when you also want terminal output. `--report-junit <path>` remains a compatibility alias for `--reporter junit:<path>`.
 - JUnit reports preserve legal Unicode and whitespace, and replace characters forbidden by XML 1.0 (such as terminal ESC or NUL) with `U+FFFD` (`�`) so CI parsers can read the report. JSON and other reporters retain the original suite values.
 - When `--fail-fast` and retries are both set, the current test still consumes its retries before the suite stops.