fix: align Maestro test discovery order

Author: thymikee

src/daemon/handlers/__tests__/session-test-discovery.test.ts

@@ -84,3 +84,42 @@ test('discoverReplayTestEntries includes Maestro yaml flows for Maestro test sui
     assert.equal(entries[0].title, 'Bottom Tabs - Dynamic');
   }
 });
+
+test('discoverReplayTestEntries preserves explicit Maestro file order', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-test-discovery-maestro-order-'));
+  const second = path.join(root, '02-second.yaml');
+  const first = path.join(root, '01-first.yaml');
+  fs.writeFileSync(first, 'appId: demo\n---\n- launchApp\n');
+  fs.writeFileSync(second, 'appId: demo\n---\n- launchApp\n');
+
+  const entries = discoverReplayTestEntries({
+    inputs: [second, first],
+    cwd: root,
+    replayBackend: 'maestro',
+  });
+
+  assert.deepEqual(
+    entries.map((entry) => path.basename(entry.path)),
+    ['02-second.yaml', '01-first.yaml'],
+  );
+});
+
+test('discoverReplayTestEntries orders Maestro file inputs before directory flows', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-test-discovery-maestro-files-'));
+  const suite = path.join(root, 'suite');
+  fs.mkdirSync(suite);
+  const explicit = path.join(root, '99-explicit.yaml');
+  fs.writeFileSync(explicit, 'appId: demo\n---\n- launchApp\n');
+  fs.writeFileSync(path.join(suite, '01-directory.yaml'), 'appId: demo\n---\n- launchApp\n');
+
+  const entries = discoverReplayTestEntries({
+    inputs: [suite, explicit],
+    cwd: root,
+    replayBackend: 'maestro',
+  });
+
+  assert.deepEqual(
+    entries.map((entry) => path.basename(entry.path)),
+    ['99-explicit.yaml', '01-directory.yaml'],
+  );
+});

src/daemon/handlers/session-test-discovery.ts

@@ -36,11 +36,7 @@ export function discoverReplayTestEntries(params: {
   const { inputs, cwd, platformFilter, replayBackend } = params;
   const extensions = replayTestExtensions(replayBackend);
   const resolvedCwd = cwd ?? process.cwd();
-  const filePaths = [
-    ...new Set(inputs.flatMap((input) => expandReplayTestInput(input, resolvedCwd, extensions))),
-  ]
-    .map((entry) => path.normalize(entry))
-    .sort((left, right) => left.localeCompare(right));
+  const filePaths = discoverReplayTestFilePaths(inputs, resolvedCwd, extensions, replayBackend);
 
   const entries: ReplayTestDiscoveryEntry[] = [];
   for (const filePath of filePaths) {
@@ -136,24 +132,60 @@ export function resolveReplayTestRetries(
   return Math.max(0, Math.min(MAX_REPLAY_TEST_RETRIES, resolved));
 }
 
-function expandReplayTestInput(input: string, cwd: string, extensions: Set<string>): string[] {
+function discoverReplayTestFilePaths(
+  inputs: string[],
+  cwd: string,
+  extensions: Set<string>,
+  replayBackend: string | undefined,
+): string[] {
+  if (!isMaestroReplayBackend(replayBackend)) {
+    return [
+      ...new Set(inputs.flatMap((input) => expandReplayTestInput(input, cwd, extensions).paths)),
+    ]
+      .map((entry) => path.normalize(entry))
+      .sort((left, right) => left.localeCompare(right));
+  }
+
+  const files: string[] = [];
+  const directories: string[] = [];
+  const globs: string[] = [];
+  for (const input of inputs) {
+    const expanded = expandReplayTestInput(input, cwd, extensions);
+    if (expanded.source === 'directory') {
+      directories.push(...expanded.paths);
+    } else if (expanded.source === 'glob') {
+      globs.push(...expanded.paths);
+    } else {
+      files.push(...expanded.paths);
+    }
+  }
+
+  return [...new Set([...files, ...directories, ...globs].map((entry) => path.normalize(entry)))];
+}
+
+function expandReplayTestInput(
+  input: string,
+  cwd: string,
+  extensions: Set<string>,
+): { paths: string[]; source: 'directory' | 'file' | 'glob' } {
   const expandedInput = SessionStore.expandHome(input, cwd);
   if (fs.existsSync(expandedInput)) {
     const stat = fs.statSync(expandedInput);
     if (stat.isDirectory()) {
-      return replayTestGlobPatterns(extensions).flatMap((pattern) =>
+      const paths = replayTestGlobPatterns(extensions).flatMap((pattern) =>
         fs
           .globSync(pattern, { cwd: expandedInput })
           .map((match) => path.join(expandedInput, match)),
       );
+      return { paths, source: 'directory' };
     }
     if (stat.isFile()) {
       if (!extensions.has(path.extname(expandedInput))) {
         throw new AppError('INVALID_ARGS', `test does not support this file type: ${input}`);
       }
-      return [expandedInput];
+      return { paths: [expandedInput], source: 'file' };
     }
-    return [];
+    return { paths: [], source: 'file' };
   }
 
   if (!looksLikeGlob(input) && !looksLikeGlob(expandedInput)) {
@@ -165,14 +197,15 @@ function expandReplayTestInput(input: string, cwd: string, extensions: Set<strin
     cwd: path.isAbsolute(expandedInput) ? undefined : cwd,
   });
 
-  return matches
+  const paths = matches
     .map((match) => (path.isAbsolute(match) ? match : path.resolve(cwd, match)))
     .filter((match) => extensions.has(path.extname(match)) && isExistingFile(match));
+  return { paths, source: 'glob' };
 }
 
 function replayTestExtensions(replayBackend: string | undefined): Set<string> {
   return isMaestroReplayBackend(replayBackend)
-    ? new Set(['.ad', '.yaml', '.yml'])
+    ? new Set(['.yaml', '.yml', '.ad'])
     : new Set(['.ad']);
 }