@expo/build-tools 18.11.0 → 18.12.1

package/dist/common/easBuildInternal.js

@@ -28,33 +28,38 @@ async function runEasBuildInternalAsync({ job, logger, env, cwd, projectRootOver
     else if (githubTriggerOptions?.autoSubmit) {
         autoSubmitArgs.push('--auto-submit');
     }
-    const result = await (0, turtle_spawn_1.default)(cmd, [
-        ...args,
-        'build:internal',
-        '--platform',
-        job.platform,
-        '--profile',
-        buildProfile,
-        ...autoSubmitArgs,
-    ], {
-        cwd,
-        env: {
-            ...env,
-            EXPO_TOKEN: (0, nullthrows_1.default)(job.secrets, 'Secrets must be defined for non-custom builds')
-                .robotAccessToken,
-            ...extraEnv,
-            EAS_PROJECT_ROOT: projectRootOverride,
-        },
-        logger,
-        // This prevents printing stdout with job secrets and credentials to logs.
-        mode: logger_1.PipeMode.STDERR_ONLY_AS_STDOUT,
-    });
-    const stdout = result.stdout.toString();
-    const parsed = JSON.parse(stdout);
-    return validateEasBuildInternalResult({
-        result: parsed,
-        oldJob: job,
-    });
+    try {
+        const result = await (0, turtle_spawn_1.default)(cmd, [
+            ...args,
+            'build:internal',
+            '--platform',
+            job.platform,
+            '--profile',
+            buildProfile,
+            ...autoSubmitArgs,
+        ], {
+            cwd,
+            env: {
+                ...env,
+                EXPO_TOKEN: (0, nullthrows_1.default)(job.secrets, 'Secrets must be defined for non-custom builds')
+                    .robotAccessToken,
+                ...extraEnv,
+                EAS_PROJECT_ROOT: projectRootOverride,
+            },
+            logger,
+            // This prevents printing stdout with job secrets and credentials to logs.
+            mode: logger_1.PipeMode.STDERR_ONLY_AS_STDOUT,
+        });
+        const stdout = result.stdout.toString();
+        const parsed = JSON.parse(stdout);
+        return validateEasBuildInternalResult({
+            result: parsed,
+            oldJob: job,
+        });
+    }
+    catch (err) {
+        throw new Error('Failed to run eas build:internal');
+    }
 }
 async function resolveEnvFromBuildProfileAsync(ctx, { cwd }) {
     const { cmd, args, extraEnv } = await (0, easCli_1.resolveEasCommandPrefixAndEnvAsync)();

package/dist/ios/pod.js

@@ -8,8 +8,8 @@ const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const semver_1 = __importDefault(require("semver"));
-const MIN_PRECOMPILED_MODULES_EXPO_VERSION = '55.0.18';
-// const PRECOMPILED_MODULES_BASE_URL = 'https://storage.googleapis.com/eas-build-precompiled-modules/';
+const MIN_PRECOMPILED_MODULES_EXPO_VERSION = '55.0.21';
+const PRECOMPILED_MODULES_BASE_URL = 'https://storage.googleapis.com/eas-build-precompiled-modules/';
 async function installPods(ctx, { infoCallbackFn }) {
     const iosDir = path_1.default.join(ctx.getReactNativeProjectDirectory(), 'ios');
     const verboseFlag = ctx.env['EAS_VERBOSE'] === '1' ? ['--verbose'] : [];
@@ -58,10 +58,9 @@ async function resolvePrecompiledModulesPodInstallEnvAsync(ctx) {
         ctx.logger.info(`Detected expo=${validExpoPackageVersion}; not enabling precompiled modules use because precompiled modules require expo>=${MIN_PRECOMPILED_MODULES_EXPO_VERSION}.`);
         return {};
     }
-    // Start rollout with Expo precompiled modules only. Add third-party modules after this is stable.
     const env = {
         EXPO_USE_PRECOMPILED_MODULES: '1',
-        // EXPO_PRECOMPILED_MODULES_BASE_URL: getPrecompiledModulesBaseUrl(),
+        EXPO_PRECOMPILED_MODULES_BASE_URL: getPrecompiledModulesBaseUrl(ctx),
     };
     ctx.logger.info(`Detected expo=${validExpoPackageVersion}; enabling precompiled modules use. Installing pods with additional environment variables.\n${Object.entries(env)
         .map(([key, value]) => `${key}=${value}`)
@@ -77,14 +76,10 @@ async function getInstalledExpoPackageVersionAsync(ctx) {
     const expoPackageJsonPath = stdout.toString().trim();
     return (await fs_extra_1.default.readJson(expoPackageJsonPath)).version;
 }
-// function getPrecompiledModulesBaseUrl<TJob extends Ios.Job>(ctx: BuildContext<TJob>): string {
-//   if (!ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL) {
-//     return PRECOMPILED_MODULES_BASE_URL;
-//   }
-//
-//   const parsedUrl = new URL(PRECOMPILED_MODULES_BASE_URL);
-//   return PRECOMPILED_MODULES_BASE_URL.replace(
-//     `${parsedUrl.protocol}//${parsedUrl.host}`,
-//     `${ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL.replace(/\/$/, '')}/${parsedUrl.host}`
-//   );
-// }
+function getPrecompiledModulesBaseUrl(ctx) {
+    if (!ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL) {
+        return PRECOMPILED_MODULES_BASE_URL;
+    }
+    const parsedUrl = new URL(PRECOMPILED_MODULES_BASE_URL);
+    return PRECOMPILED_MODULES_BASE_URL.replace(`${parsedUrl.protocol}//${parsedUrl.host}`, `${ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL.replace(/\/$/, '')}/${parsedUrl.host}`);
+}

package/dist/steps/easFunctions.js

@@ -41,6 +41,7 @@ const startAgentDeviceRemoteSession_1 = require("./functions/startAgentDeviceRem
 const startAndroidEmulator_1 = require("./functions/startAndroidEmulator");
 const startCuttlefishDevice_1 = require("./functions/startCuttlefishDevice");
 const startIosSimulator_1 = require("./functions/startIosSimulator");
+const startServeSimRemoteSession_1 = require("./functions/startServeSimRemoteSession");
 const uploadArtifact_1 = require("./functions/uploadArtifact");
 const uploadToAsc_1 = require("./functions/uploadToAsc");
 const useNpmToken_1 = require("./functions/useNpmToken");
@@ -75,10 +76,11 @@ function getEasFunctions(ctx) {
         (0, generateGymfileFromTemplate_1.generateGymfileFromTemplateFunction)(),
         (0, runFastlane_1.runFastlaneFunction)(),
         (0, parseXcactivitylog_1.parseXcactivitylogFunction)(),
-        (0, startAgentDeviceRemoteSession_1.createStartAgentDeviceRemoteSessionBuildFunction)(),
+        (0, startAgentDeviceRemoteSession_1.createStartAgentDeviceRemoteSessionBuildFunction)(ctx),
         (0, startAndroidEmulator_1.createStartAndroidEmulatorBuildFunction)(),
         (0, startCuttlefishDevice_1.createStartCuttlefishDeviceBuildFunction)(),
         (0, startIosSimulator_1.createStartIosSimulatorBuildFunction)(),
+        (0, startServeSimRemoteSession_1.createStartServeSimRemoteSessionBuildFunction)(ctx),
         (0, installMaestro_1.createInstallMaestroBuildFunction)(),
         (0, installPods_1.createInstallPodsBuildFunction)(),
         (0, sendSlackMessage_1.createSendSlackMessageFunction)(),

package/dist/steps/functions/maestroFlowDiscovery.d.ts

@@ -0,0 +1,9 @@
+import type { bunyan } from '@expo/logger';
+export interface BuildFlowNameToPathMapArgs {
+    inputFlowPaths: string[];
+    projectRoot: string;
+    logger: bunyan;
+}
+export declare function buildFlowNameToPathMap(args: BuildFlowNameToPathMapArgs): Promise<Map<string, string> | null>;
+export declare function walkDir(dir: string, visited: Set<string>, out: string[], logger: bunyan): Promise<void>;
+export declare function readFlowName(absFile: string): Promise<string>;

package/dist/steps/functions/maestroFlowDiscovery.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFlowNameToPathMap = buildFlowNameToPathMap;
+exports.walkDir = walkDir;
+exports.readFlowName = readFlowName;
+const results_1 = require("@expo/results");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const YAML_EXT = /\.ya?ml$/i;
+const WORKSPACE_CONFIG_BASENAME = 'config.yaml';
+async function buildFlowNameToPathMap(args) {
+    try {
+        const flows = await discoverFlows(args);
+        return dedupAndDetectDuplicates(flows, args.logger);
+    }
+    catch (err) {
+        args.logger.warn(`buildFlowNameToPathMap failed unexpectedly: ${err?.message ?? String(err)}`);
+        return null;
+    }
+}
+async function discoverFlows({ inputFlowPaths, projectRoot, logger, }) {
+    const realRootResult = await (0, results_1.asyncResult)(promises_1.default.realpath(projectRoot));
+    const realRoot = realRootResult.ok ? realRootResult.value : projectRoot;
+    const fileLists = await Promise.all(inputFlowPaths.map(async (input) => {
+        const abs = path_1.default.resolve(projectRoot, input);
+        const statResult = await (0, results_1.asyncResult)(promises_1.default.stat(abs));
+        if (!statResult.ok) {
+            logger.warn(`flow_path entry "${input}" not found, skipping`);
+            return [];
+        }
+        const stat = statResult.value;
+        if (stat.isFile() && YAML_EXT.test(abs)) {
+            return [abs];
+        }
+        if (stat.isDirectory()) {
+            const out = [];
+            await walkDir(abs, new Set(), out, logger);
+            return out;
+        }
+        return [];
+    }));
+    return Promise.all(fileLists.flat().map(absFile => makeEntry(absFile, realRoot)));
+}
+async function makeEntry(absFile, realRoot) {
+    const [name, realFileResult] = await Promise.all([
+        readFlowName(absFile),
+        (0, results_1.asyncResult)(promises_1.default.realpath(absFile)),
+    ]);
+    const realFile = realFileResult.ok ? realFileResult.value : absFile;
+    const rel = path_1.default.relative(realRoot, realFile);
+    const value = rel.startsWith('..') || path_1.default.isAbsolute(rel) ? absFile : rel;
+    return { name, path: value, realpath: realFile };
+}
+function dedupAndDetectDuplicates(flows, logger) {
+    const byKey = new Map();
+    for (const f of flows) {
+        if (!byKey.has(f.realpath)) {
+            byKey.set(f.realpath, f);
+        }
+    }
+    const unique = [...byKey.values()];
+    const nameToPath = new Map();
+    const duplicates = new Map();
+    for (const f of unique) {
+        if (nameToPath.has(f.name)) {
+            const existing = nameToPath.get(f.name);
+            const list = duplicates.get(f.name) ?? [existing];
+            list.push(f.path);
+            duplicates.set(f.name, list);
+        }
+        nameToPath.set(f.name, f.path);
+    }
+    if (duplicates.size > 0) {
+        for (const [name, paths] of duplicates) {
+            logger.warn(`Duplicate Maestro flow name "${name}" across paths: ${paths.join(', ')}.`);
+        }
+        logger.warn('Retry-failed-only is disabled for this run; will retry all flows on failure. ' +
+            'Give each Maestro flow a unique name (file basename or top-level name) to enable retry-failed-only.');
+        return null;
+    }
+    return nameToPath;
+}
+async function walkDir(dir, visited, out, logger) {
+    // Cycle protection: dedup on realpath (fall back to the original path when
+    // realpath fails so we still make progress on missing or restricted dirs).
+    const realResult = await (0, results_1.asyncResult)(promises_1.default.realpath(dir));
+    const real = realResult.ok ? realResult.value : dir;
+    if (visited.has(real)) {
+        return;
+    }
+    visited.add(real);
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        logger.warn(`readdir failed for ${dir}: ${err?.message ?? String(err)}`);
+        return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isSymbolicLink()) {
+            const tgtResult = await (0, results_1.asyncResult)(promises_1.default.stat(full));
+            if (!tgtResult.ok) {
+                continue;
+            }
+            const tgt = tgtResult.value;
+            if (tgt.isDirectory()) {
+                await walkDir(full, visited, out, logger);
+            }
+            else if (tgt.isFile() && isYamlFile(entry.name) && !isWorkspaceConfig(entry.name)) {
+                out.push(full);
+            }
+        }
+        else if (entry.isDirectory()) {
+            await walkDir(full, visited, out, logger);
+        }
+        else if (entry.isFile()) {
+            if (isYamlFile(entry.name) && !isWorkspaceConfig(entry.name)) {
+                out.push(full);
+            }
+        }
+    }
+}
+async function readFlowName(absFile) {
+    const ext = path_1.default.extname(absFile);
+    const fallback = path_1.default.basename(absFile, ext);
+    let content;
+    try {
+        content = await promises_1.default.readFile(absFile, 'utf-8');
+    }
+    catch {
+        return fallback;
+    }
+    let firstDoc;
+    try {
+        const docs = yaml_1.default.parseAllDocuments(content);
+        firstDoc = docs[0];
+    }
+    catch {
+        return fallback;
+    }
+    if (!firstDoc || firstDoc.errors.length > 0) {
+        return fallback;
+    }
+    const parsed = firstDoc.toJS();
+    const name = parsed?.name;
+    if (typeof name === 'string' && name.length > 0) {
+        return name;
+    }
+    return fallback;
+}
+function isYamlFile(name) {
+    return YAML_EXT.test(name);
+}
+function isWorkspaceConfig(name) {
+    return name.toLowerCase() === WORKSPACE_CONFIG_BASENAME;
+}

package/dist/steps/functions/maestroResultParser.d.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 export interface MaestroFlowResult {
     name: string;
     path: string;
@@ -9,7 +8,6 @@ export interface MaestroFlowResult {
     tags: string[];
     properties: Record<string, string>;
 }
-export declare function extractFlowKey(filename: string, prefix: string): string | null;
 export interface JUnitTestCaseResult {
     name: string;
     status: 'passed' | 'failed';
@@ -19,40 +17,19 @@ export interface JUnitTestCaseResult {
     properties: Record<string, string>;
 }
 export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
-declare const FlowMetadataFileSchema: z.ZodObject<{
-    flow_name: z.ZodString;
-    flow_file_path: z.ZodString;
-}, z.core.$strip>;
-type FlowMetadata = z.output<typeof FlowMetadataFileSchema>;
-/**
- * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
- *
- * The file contains:
- * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
- *   the flow filename without extension.
- *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
- * - `flow_file_path`: absolute path to the original flow YAML file.
- * - `outputs`: screenshot defect data (unused here).
- *
- * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
- * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
- */
-export declare function parseFlowMetadata(filePath: string): Promise<FlowMetadata | null>;
-export declare function parseMaestroResults(junitDirectory: string, testsDirectory: string, projectRoot: string): Promise<MaestroFlowResult[]>;
+export declare function parseMaestroResults(junitDirectory: string, nameToPath: Map<string, string> | null): Promise<MaestroFlowResult[]>;
 /**
  * Returns the subset of `inputFlowPaths` whose testcases failed in the given
  * attempt's JUnit file, or `null` when the result cannot be trusted (caller
  * then falls back to dumb retry — re-run everything).
  *
- * Mapping: <testcase> only carries `name`, so we recover `flow_file_path`
- * from `ai-${flow_name}.json` under testsDirectory and match it back to
- * inputFlowPaths.
+ * Caller passes a precomputed `nameToPath` map built from the user's
+ * `inputFlowPaths`. We translate failed testcase names to flow paths via
+ * that map; unknown names → null.
  */
 export declare function parseFailedFlowsFromJUnit(args: {
     junitFile: string;
-    testsDirectory: string;
-    inputFlowPaths: string[];
-    projectRoot: string;
+    nameToPath: Map<string, string>;
 }): Promise<string[] | null>;
 /**
  * Reads every *.xml in sourceDir (per-attempt JUnit files), picks the latest
@@ -79,4 +56,3 @@ export declare function copyLatestAttemptXml(args: {
     sourceDir: string;
     outputPath: string;
 }): Promise<void>;
-export {};

package/dist/steps/functions/maestroResultParser.js

@@ -3,9 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFlowKey = extractFlowKey;
 exports.parseJUnitTestCases = parseJUnitTestCases;
-exports.parseFlowMetadata = parseFlowMetadata;
 exports.parseMaestroResults = parseMaestroResults;
 exports.parseFailedFlowsFromJUnit = parseFailedFlowsFromJUnit;
 exports.mergeJUnitReports = mergeJUnitReports;
@@ -13,15 +11,8 @@ exports.copyLatestAttemptXml = copyLatestAttemptXml;
 const fast_xml_parser_1 = require("fast-xml-parser");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-const zod_1 = require("zod");
-// Maestro's TestDebugReporter creates timestamped directories, e.g. "2024-06-15_143022"
-const TIMESTAMP_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{6}$/;
 // Per-attempt JUnit XML files use `*-attempt-N.xml` names; this extracts N.
 const ATTEMPT_PATTERN = /attempt-(\d+)/;
-function extractFlowKey(filename, prefix) {
-    const match = filename.match(new RegExp(`^${prefix}-(.+)\\.json$`));
-    return match?.[1] ?? null;
-}
 const xmlParser = new fast_xml_parser_1.XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: '@_',
@@ -112,35 +103,7 @@ async function parseJUnitTestCases(junitDirectory) {
     const perFile = await Promise.all(xmlFiles.map(f => parseJUnitFile(path_1.default.join(junitDirectory, f))));
     return perFile.flat();
 }
-const FlowMetadataFileSchema = zod_1.z.object({
-    flow_name: zod_1.z.string(),
-    flow_file_path: zod_1.z.string(),
-});
-/**
- * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
- *
- * The file contains:
- * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
- *   the flow filename without extension.
- *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
- * - `flow_file_path`: absolute path to the original flow YAML file.
- * - `outputs`: screenshot defect data (unused here).
- *
- * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
- * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
- */
-async function parseFlowMetadata(filePath) {
-    try {
-        const content = await promises_1.default.readFile(filePath, 'utf-8');
-        const data = JSON.parse(content);
-        return FlowMetadataFileSchema.parse(data);
-    }
-    catch {
-        return null;
-    }
-}
-async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot) {
-    // 1. Parse JUnit XML files, tracking which file each result came from
+async function parseMaestroResults(junitDirectory, nameToPath) {
     let junitEntries;
     try {
         junitEntries = await promises_1.default.readdir(junitDirectory);
@@ -162,44 +125,7 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     if (junitResultsWithSource.length === 0) {
         return [];
     }
-    // 2. Parse ai-*.json from debug output for flow_file_path + retryCount
-    const flowPathMap = new Map(); // flowName → flowFilePath
-    const flowOccurrences = new Map(); // flowName → count
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(testsDirectory);
-    }
-    catch {
-        entries = [];
-    }
-    const timestampDirs = entries.filter(name => TIMESTAMP_DIR_PATTERN.test(name)).sort();
-    for (const dir of timestampDirs) {
-        const dirPath = path_1.default.join(testsDirectory, dir);
-        let files;
-        try {
-            files = await promises_1.default.readdir(dirPath);
-        }
-        catch {
-            continue;
-        }
-        for (const file of files) {
-            const flowKey = extractFlowKey(file, 'ai');
-            if (!flowKey) {
-                continue;
-            }
-            const metadata = await parseFlowMetadata(path_1.default.join(dirPath, file));
-            if (!metadata) {
-                continue;
-            }
-            // Track latest path (last timestamp dir wins)
-            flowPathMap.set(metadata.flow_name, metadata.flow_file_path);
-            // Count occurrences for retryCount
-            flowOccurrences.set(metadata.flow_name, (flowOccurrences.get(metadata.flow_name) ?? 0) + 1);
-        }
-    }
-    // 3. Merge: JUnit results + ai-*.json metadata
     const results = [];
-    // Group results by flow name
     const resultsByName = new Map();
     for (const entry of junitResultsWithSource) {
         const group = resultsByName.get(entry.result.name) ?? [];
@@ -207,49 +133,28 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
         resultsByName.set(entry.result.name, group);
     }
     for (const [flowName, flowEntries] of resultsByName) {
-        const flowFilePath = flowPathMap.get(flowName);
-        const relativePath = flowFilePath
-            ? await relativizePathAsync(flowFilePath, projectRoot)
-            : flowName;
-        if (flowEntries.length === 1) {
-            // Single result for this flow — use ai-*.json occurrence count for retryCount
-            // (backward compat with old-style single JUnit file that gets overwritten)
-            const { result } = flowEntries[0];
-            const occurrences = flowOccurrences.get(flowName) ?? 0;
-            const retryCount = Math.max(0, occurrences - 1);
+        const flowPath = nameToPath?.get(flowName) ?? flowName;
+        // retryCount is derived from each entry's source filename (`attempt-N`);
+        // a single entry from `report.xml` (no marker) collapses to attempt 0.
+        const sorted = flowEntries
+            .map(entry => {
+            const match = entry.sourceFile.match(ATTEMPT_PATTERN);
+            const attemptIndex = match ? parseInt(match[1], 10) : 0;
+            return { ...entry, attemptIndex };
+        })
+            .sort((a, b) => a.attemptIndex - b.attemptIndex);
+        for (const { result, attemptIndex } of sorted) {
             results.push({
                 name: flowName,
-                path: relativePath,
+                path: flowPath,
                 status: result.status,
                 errorMessage: result.errorMessage,
                 duration: result.duration,
-                retryCount,
+                retryCount: attemptIndex,
                 tags: result.tags,
                 properties: result.properties,
             });
         }
-        else {
-            // Multiple results — per-attempt JUnit files. Sort by attempt index from filename.
-            const sorted = flowEntries
-                .map(entry => {
-                const match = entry.sourceFile.match(ATTEMPT_PATTERN);
-                const attemptIndex = match ? parseInt(match[1], 10) : 0;
-                return { ...entry, attemptIndex };
-            })
-                .sort((a, b) => a.attemptIndex - b.attemptIndex);
-            for (const { result, attemptIndex } of sorted) {
-                results.push({
-                    name: flowName,
-                    path: relativePath,
-                    status: result.status,
-                    errorMessage: result.errorMessage,
-                    duration: result.duration,
-                    retryCount: attemptIndex,
-                    tags: result.tags,
-                    properties: result.properties,
-                });
-            }
-        }
     }
     return results;
 }
@@ -258,13 +163,13 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
  * attempt's JUnit file, or `null` when the result cannot be trusted (caller
  * then falls back to dumb retry — re-run everything).
  *
- * Mapping: <testcase> only carries `name`, so we recover `flow_file_path`
- * from `ai-${flow_name}.json` under testsDirectory and match it back to
- * inputFlowPaths.
+ * Caller passes a precomputed `nameToPath` map built from the user's
+ * `inputFlowPaths`. We translate failed testcase names to flow paths via
+ * that map; unknown names → null.
  */
 async function parseFailedFlowsFromJUnit(args) {
     // fast-xml-parser is lenient — truncated XML can produce a partial parse
-    // with some testcases dropped. Trusting that subset for smart retry would
+    // with some testcases dropped. Trusting that subset for retry-failed-only would
     // skip retries for cut-off flows; reject any malformed XML and fall back
     // to dumb retry.
     let content;
@@ -286,8 +191,9 @@ async function parseFailedFlowsFromJUnit(args) {
         return [];
     }
     // Two testcases with the same name (pass+fail or fail+fail) make it
-    // impossible to map back to a single input flow_path, since the
-    // ai-*.json keyed map collapses duplicates. Signal "unknown" → dumb retry.
+    // impossible to map back to a single input flow_path. Signal "unknown".
+    // Complementary to the map-build duplicate check (which catches the case
+    // where tag filter hides duplication from JUnit).
     const allNameCounts = new Map();
     for (const tc of testcases) {
         allNameCounts.set(tc.name, (allNameCounts.get(tc.name) ?? 0) + 1);
@@ -297,60 +203,16 @@ async function parseFailedFlowsFromJUnit(args) {
             return null;
         }
     }
-    // Build flow_name → flow_file_path map from ai-*.json across timestamped
-    // subdirectories (same traversal as parseMaestroResults).
-    const nameToPath = new Map();
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(args.testsDirectory);
-    }
-    catch {
-        entries = [];
-    }
-    const timestampDirs = entries.filter(name => TIMESTAMP_DIR_PATTERN.test(name)).sort();
-    for (const dir of timestampDirs) {
-        const dirPath = path_1.default.join(args.testsDirectory, dir);
-        let files;
-        try {
-            files = await promises_1.default.readdir(dirPath);
-        }
-        catch {
-            continue;
-        }
-        for (const file of files) {
-            const flowKey = extractFlowKey(file, 'ai');
-            if (!flowKey) {
-                continue;
-            }
-            const metadata = await parseFlowMetadata(path_1.default.join(dirPath, file));
-            if (!metadata) {
-                continue;
-            }
-            // Latest timestamp dir wins if the same flow appears in multiple attempts.
-            nameToPath.set(metadata.flow_name, metadata.flow_file_path);
-        }
-    }
     const matched = [];
     for (const tc of failing) {
-        const abs = nameToPath.get(tc.name);
-        if (!abs) {
-            return null; // unknown mapping; safer to fall back
-        }
-        const relative = await relativizePathAsync(abs, args.projectRoot);
-        // Accept exact matches and flow files discovered under an input directory
-        // (documented usage: `flow_path: ./maestro/flows` discovers nested .yml).
-        // Anything outside every input is treated as out-of-scope → dumb retry.
-        if (!args.inputFlowPaths.some(input => isPathWithinOrEqual(relative, input))) {
+        const p = args.nameToPath.get(tc.name);
+        if (p === undefined) {
             return null;
         }
-        matched.push(relative);
+        matched.push(p);
     }
     return matched;
 }
-function isPathWithinOrEqual(child, parent) {
-    const rel = path_1.default.relative(parent, child);
-    return rel === '' || (!rel.startsWith('..') && !path_1.default.isAbsolute(rel));
-}
 /**
  * Reads every *.xml in sourceDir (per-attempt JUnit files), picks the latest
  * attempt's <testcase> per unique flow name (latest determined from the
@@ -495,24 +357,3 @@ async function copyLatestAttemptXml(args) {
     }
     await promises_1.default.copyFile(path_1.default.join(args.sourceDir, winner), args.outputPath);
 }
-async function relativizePathAsync(flowFilePath, projectRoot) {
-    if (!path_1.default.isAbsolute(flowFilePath)) {
-        return flowFilePath;
-    }
-    // Resolve symlinks (e.g., /tmp -> /private/tmp on macOS) for consistent comparison
-    let resolvedRoot = projectRoot;
-    let resolvedFlow = flowFilePath;
-    try {
-        resolvedRoot = await promises_1.default.realpath(projectRoot);
-    }
-    catch { }
-    try {
-        resolvedFlow = await promises_1.default.realpath(flowFilePath);
-    }
-    catch { }
-    const relative = path_1.default.relative(resolvedRoot, resolvedFlow);
-    if (relative.startsWith('..')) {
-        return flowFilePath;
-    }
-    return relative;
-}