@vostride/agent-qa-core 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -93,14 +93,14 @@ function toObservationFrontmatter(data) {
 }
 async function ensureMemoryDirs(root) {
   await Promise.all(
-    MEMORY_TIERS.map((tier) => (0, import_promises8.mkdir)((0, import_node_path11.join)(root, tier), { recursive: true }))
+    MEMORY_TIERS.map((tier) => (0, import_promises8.mkdir)((0, import_node_path12.join)(root, tier), { recursive: true }))
   );
 }
 async function writeObservation(root, tier, scope, data) {
-  const dir = (0, import_node_path11.join)(root, tier, scope);
-  const resolved = (0, import_node_path11.resolve)(dir);
-  const boundary = (0, import_node_path11.resolve)(root);
-  if (!resolved.startsWith(boundary + import_node_path11.sep)) {
+  const dir = (0, import_node_path12.join)(root, tier, scope);
+  const resolved = (0, import_node_path12.resolve)(dir);
+  const boundary = (0, import_node_path12.resolve)(root);
+  if (!resolved.startsWith(boundary + import_node_path12.sep)) {
     throw new Error(`Scope "${scope}" escapes memory root`);
   }
   const schema = "position" in data ? SuiteObservationWriteSchema : BaseObservationWriteSchema;
@@ -111,7 +111,7 @@ async function writeObservation(root, tier, scope, data) {
 ${(0, import_yaml3.stringify)({ ...frontmatter }, { lineWidth: 0 })}---
 ${validated.content}
 `;
-  const filePath = (0, import_node_path11.join)(dir, `${data.id}.md`);
+  const filePath = (0, import_node_path12.join)(dir, `${data.id}.md`);
   await (0, import_promises8.writeFile)(filePath, content, "utf-8");
   return filePath;
 }
@@ -158,13 +158,13 @@ async function listObservations(dir) {
   }
   return entries.filter((f) => f.startsWith("obs_") && f.endsWith(".md")).sort();
 }
-var import_yaml3, import_promises8, import_node_path11, MEMORY_TIERS;
+var import_yaml3, import_promises8, import_node_path12, MEMORY_TIERS;
 var init_observation_io = __esm({
   "src/memory/observation-io.ts"() {
     "use strict";
     import_yaml3 = require("yaml");
     import_promises8 = require("fs/promises");
-    import_node_path11 = require("path");
+    import_node_path12 = require("path");
     init_schema();
     MEMORY_TIERS = ["products", "suites", "tests"];
   }
@@ -238,14 +238,14 @@ function isBetterSqlite3NodeGypSymlinkConflict(error) {
   return message.includes("node_gyp_bins/python3") && message.includes("EEXIST");
 }
 function resolveCurrentRuntimeNpmCliPath() {
-  const nodeInstallRoot = (0, import_node_path18.dirname)((0, import_node_path18.dirname)(process.execPath));
-  const npmCliPath = (0, import_node_path18.join)(nodeInstallRoot, "lib", "node_modules", "npm", "bin", "npm-cli.js");
-  return (0, import_node_fs6.existsSync)(npmCliPath) ? npmCliPath : null;
+  const nodeInstallRoot = (0, import_node_path19.dirname)((0, import_node_path19.dirname)(process.execPath));
+  const npmCliPath = (0, import_node_path19.join)(nodeInstallRoot, "lib", "node_modules", "npm", "bin", "npm-cli.js");
+  return (0, import_node_fs7.existsSync)(npmCliPath) ? npmCliPath : null;
 }
 function resolveCurrentRuntimeNodeDir() {
-  const nodeInstallRoot = (0, import_node_path18.dirname)((0, import_node_path18.dirname)(process.execPath));
-  const nodeHeaderPath = (0, import_node_path18.join)(nodeInstallRoot, "include", "node", "node.h");
-  return (0, import_node_fs6.existsSync)(nodeHeaderPath) ? nodeInstallRoot : null;
+  const nodeInstallRoot = (0, import_node_path19.dirname)((0, import_node_path19.dirname)(process.execPath));
+  const nodeHeaderPath = (0, import_node_path19.join)(nodeInstallRoot, "include", "node", "node.h");
+  return (0, import_node_fs7.existsSync)(nodeHeaderPath) ? nodeInstallRoot : null;
 }
 function resolveBetterSqliteRebuildCommand() {
   const npmCliPath = resolveCurrentRuntimeNpmCliPath();
@@ -266,31 +266,31 @@ function sleepSync(milliseconds) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
 }
 function waitForBetterSqlite3BuildOutput(installRoot, timeoutMs = 3e4) {
-  const bindingPath = (0, import_node_path18.join)(installRoot, "build", "Release", "better_sqlite3.node");
+  const bindingPath = (0, import_node_path19.join)(installRoot, "build", "Release", "better_sqlite3.node");
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    if ((0, import_node_fs6.existsSync)(bindingPath)) {
+    if ((0, import_node_fs7.existsSync)(bindingPath)) {
       return true;
     }
     sleepSync(200);
   }
-  return (0, import_node_fs6.existsSync)(bindingPath);
+  return (0, import_node_fs7.existsSync)(bindingPath);
 }
 function acquireBetterSqlite3RebuildLock(installRoot) {
-  const lockRoot = (0, import_node_path18.join)((0, import_node_os3.tmpdir)(), "agent-qa-better-sqlite3-rebuild-locks");
+  const lockRoot = (0, import_node_path19.join)((0, import_node_os3.tmpdir)(), "agent-qa-better-sqlite3-rebuild-locks");
   const lockKey = (0, import_node_crypto6.createHash)("sha256").update(`${installRoot}\0${process.version}`).digest("hex");
-  const lockDir = (0, import_node_path18.join)(lockRoot, lockKey);
+  const lockDir = (0, import_node_path19.join)(lockRoot, lockKey);
   const deadline = Date.now() + 12e4;
-  (0, import_node_fs6.mkdirSync)(lockRoot, { recursive: true });
+  (0, import_node_fs7.mkdirSync)(lockRoot, { recursive: true });
   while (true) {
     try {
-      (0, import_node_fs6.mkdirSync)(lockDir);
-      (0, import_node_fs6.writeFileSync)((0, import_node_path18.join)(lockDir, "owner"), `${process.pid}
+      (0, import_node_fs7.mkdirSync)(lockDir);
+      (0, import_node_fs7.writeFileSync)((0, import_node_path19.join)(lockDir, "owner"), `${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 ${installRoot}
 `);
       return () => {
-        (0, import_node_fs6.rmSync)(lockDir, { recursive: true, force: true });
+        (0, import_node_fs7.rmSync)(lockDir, { recursive: true, force: true });
       };
     } catch (error) {
       const code = error instanceof Error && "code" in error ? error.code : void 0;
@@ -298,7 +298,7 @@ ${installRoot}
         throw error;
       }
       if (Date.now() > deadline) {
-        (0, import_node_fs6.rmSync)(lockDir, { recursive: true, force: true });
+        (0, import_node_fs7.rmSync)(lockDir, { recursive: true, force: true });
         continue;
       }
       sleepSync(200);
@@ -314,13 +314,13 @@ function rebuildBetterSqlite3ForCurrentRuntime(originalError) {
   }
   rebuildAttempted = true;
   const packageJsonPath = require2.resolve("better-sqlite3/package.json");
-  const installRoot = (0, import_node_path18.dirname)(packageJsonPath);
+  const installRoot = (0, import_node_path19.dirname)(packageJsonPath);
   const rebuildCommand = resolveBetterSqliteRebuildCommand();
-  const nodeGypDevDir = (0, import_node_path18.join)((0, import_node_os3.tmpdir)(), "agent-qa-node-gyp", process.version.replace(/^v/, ""));
-  const npmCacheDir = (0, import_node_path18.join)((0, import_node_os3.tmpdir)(), "agent-qa-npm-cache");
+  const nodeGypDevDir = (0, import_node_path19.join)((0, import_node_os3.tmpdir)(), "agent-qa-node-gyp", process.version.replace(/^v/, ""));
+  const npmCacheDir = (0, import_node_path19.join)((0, import_node_os3.tmpdir)(), "agent-qa-npm-cache");
   const nodeDir = resolveCurrentRuntimeNodeDir();
-  const nodeGypBinsPath = (0, import_node_path18.join)(installRoot, "build", "node_gyp_bins");
-  const buildRoot = (0, import_node_path18.join)(installRoot, "build");
+  const nodeGypBinsPath = (0, import_node_path19.join)(installRoot, "build", "node_gyp_bins");
+  const buildRoot = (0, import_node_path19.join)(installRoot, "build");
   const releaseLock = acquireBetterSqlite3RebuildLock(installRoot);
   try {
     clearBetterSqlite3Cache();
@@ -333,10 +333,10 @@ function rebuildBetterSqlite3ForCurrentRuntime(originalError) {
         throw error;
       }
     }
-    (0, import_node_fs6.mkdirSync)(nodeGypDevDir, { recursive: true });
-    (0, import_node_fs6.mkdirSync)(npmCacheDir, { recursive: true });
-    (0, import_node_fs6.rmSync)(buildRoot, { recursive: true, force: true });
-    (0, import_node_fs6.rmSync)(nodeGypBinsPath, { recursive: true, force: true });
+    (0, import_node_fs7.mkdirSync)(nodeGypDevDir, { recursive: true });
+    (0, import_node_fs7.mkdirSync)(npmCacheDir, { recursive: true });
+    (0, import_node_fs7.rmSync)(buildRoot, { recursive: true, force: true });
+    (0, import_node_fs7.rmSync)(nodeGypBinsPath, { recursive: true, force: true });
     if (!process.env.VITEST) {
       console.warn(`[agent-qa] Rebuilding better-sqlite3 for Node ${process.version} in ${installRoot}`);
     }
@@ -390,16 +390,16 @@ function createBetterSqlite3Database(path5) {
     return openBetterSqlite3Database(path5);
   }
 }
-var import_node_child_process2, import_node_fs6, import_node_crypto6, import_node_module3, import_node_os3, import_node_path18, import_meta3, require2, sqliteConstructor, rebuildAttempted, rebuildFailureMessage;
+var import_node_child_process2, import_node_fs7, import_node_crypto6, import_node_module3, import_node_os3, import_node_path19, import_meta3, require2, sqliteConstructor, rebuildAttempted, rebuildFailureMessage;
 var init_sqlite = __esm({
   "src/sqlite.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
-    import_node_fs6 = require("fs");
+    import_node_fs7 = require("fs");
     import_node_crypto6 = require("crypto");
     import_node_module3 = require("module");
     import_node_os3 = require("os");
-    import_node_path18 = require("path");
+    import_node_path19 = require("path");
     import_meta3 = {};
     require2 = (0, import_node_module3.createRequire)(import_meta3.url);
     sqliteConstructor = null;
@@ -430,13 +430,13 @@ async function buildMemoryIndex(params) {
     const insert = db.prepare("INSERT INTO observations(title, content, id, trust) VALUES (?, ?, ?, ?)");
     const dirs = [];
     if (validatePathComponent(params.product)) {
-      dirs.push({ path: (0, import_node_path19.join)(params.memoryRoot, "products", params.product), isSuite: false });
+      dirs.push({ path: (0, import_node_path20.join)(params.memoryRoot, "products", params.product), isSuite: false });
     }
     if (params.suiteId && validatePathComponent(params.suiteId)) {
-      dirs.push({ path: (0, import_node_path19.join)(params.memoryRoot, "suites", params.suiteId), isSuite: true });
+      dirs.push({ path: (0, import_node_path20.join)(params.memoryRoot, "suites", params.suiteId), isSuite: true });
     }
     if (validatePathComponent(params.testId)) {
-      dirs.push({ path: (0, import_node_path19.join)(params.memoryRoot, "tests", params.testId), isSuite: false });
+      dirs.push({ path: (0, import_node_path20.join)(params.memoryRoot, "tests", params.testId), isSuite: false });
     }
     if (dirs.length === 0) {
       console.warn("[memory-index] All path components failed validation", {
@@ -455,7 +455,7 @@ async function buildMemoryIndex(params) {
     for (const { path: dirPath, isSuite } of dirs) {
       const filenames = await listObservations(dirPath);
       for (const filename of filenames) {
-        const filePath = (0, import_node_path19.join)(dirPath, filename);
+        const filePath = (0, import_node_path20.join)(dirPath, filename);
         let raw;
         try {
           raw = await (0, import_promises14.readFile)(filePath, "utf-8");
@@ -485,12 +485,12 @@ async function buildMemoryIndex(params) {
     return null;
   }
 }
-var import_promises14, import_node_path19;
+var import_promises14, import_node_path20;
 var init_memory_index = __esm({
   "src/memory/memory-index.ts"() {
     "use strict";
     import_promises14 = require("fs/promises");
-    import_node_path19 = require("path");
+    import_node_path20 = require("path");
     init_observation_io();
     init_security_scanner();
     init_sqlite();
@@ -508,12 +508,12 @@ var init_xml_escape = __esm({
 });
 
 // src/memory/lock-manager.ts
-var import_promises15, import_node_path20, LockManager;
+var import_promises15, import_node_path21, LockManager;
 var init_lock_manager = __esm({
   "src/memory/lock-manager.ts"() {
     "use strict";
     import_promises15 = require("fs/promises");
-    import_node_path20 = require("path");
+    import_node_path21 = require("path");
     LockManager = class {
       lockPath;
       timeout;
@@ -522,7 +522,7 @@ var init_lock_manager = __esm({
         this.timeout = timeout;
       }
       async acquire() {
-        await (0, import_promises15.mkdir)((0, import_node_path20.dirname)(this.lockPath), { recursive: true });
+        await (0, import_promises15.mkdir)((0, import_node_path21.dirname)(this.lockPath), { recursive: true });
         const deadline = Date.now() + this.timeout;
         while (Date.now() < deadline) {
           try {
@@ -654,12 +654,12 @@ var local_provider_exports = {};
 __export(local_provider_exports, {
   LocalMemoryProvider: () => LocalMemoryProvider
 });
-var import_node_path21, import_node_fs7, import_promises16, LocalMemoryProvider;
+var import_node_path22, import_node_fs8, import_promises16, LocalMemoryProvider;
 var init_local_provider = __esm({
   "src/memory/local-provider.ts"() {
     "use strict";
-    import_node_path21 = require("path");
-    import_node_fs7 = require("fs");
+    import_node_path22 = require("path");
+    import_node_fs8 = require("fs");
     import_promises16 = require("fs/promises");
     init_memory_index();
     init_xml_escape();
@@ -681,7 +681,7 @@ var init_local_provider = __esm({
         this.minTrust = opts?.minTrust ?? 0.3;
         this.maxInjections = opts?.maxInjections ?? 3;
         this.lockManager = new LockManager(
-          (0, import_node_path21.join)(this.memoryRoot, ".curator.lock"),
+          (0, import_node_path22.join)(this.memoryRoot, ".curator.lock"),
           opts?.curatorLockTimeout ?? 12e4
         );
       }
@@ -751,9 +751,9 @@ ${lines.join("\n")}
         return writeObservation(this.memoryRoot, tier, scope, data);
       }
       async deleteObservation(tier, scope, id) {
-        const filePath = (0, import_node_path21.join)(this.memoryRoot, tier, scope, `${id}.md`);
-        const resolved = (0, import_node_path21.resolve)(filePath);
-        if (!resolved.startsWith((0, import_node_path21.resolve)(this.memoryRoot) + import_node_path21.sep)) {
+        const filePath = (0, import_node_path22.join)(this.memoryRoot, tier, scope, `${id}.md`);
+        const resolved = (0, import_node_path22.resolve)(filePath);
+        if (!resolved.startsWith((0, import_node_path22.resolve)(this.memoryRoot) + import_node_path22.sep)) {
           throw new Error("Path escapes memory root");
         }
         try {
@@ -770,25 +770,25 @@ ${lines.join("\n")}
           const results = [];
           const tiers = ["products", "suites", "tests"];
           for (const tier of tiers) {
-            const tierDir = (0, import_node_path21.join)(this.memoryRoot, tier);
+            const tierDir = (0, import_node_path22.join)(this.memoryRoot, tier);
             let scopes;
             try {
-              scopes = (0, import_node_fs7.readdirSync)(tierDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+              scopes = (0, import_node_fs8.readdirSync)(tierDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
             } catch {
               continue;
             }
             for (const scope of scopes) {
-              const scopeDir = (0, import_node_path21.join)(tierDir, scope);
+              const scopeDir = (0, import_node_path22.join)(tierDir, scope);
               let files;
               try {
-                files = (0, import_node_fs7.readdirSync)(scopeDir).filter((f) => f.startsWith("obs_") && f.endsWith(".md"));
+                files = (0, import_node_fs8.readdirSync)(scopeDir).filter((f) => f.startsWith("obs_") && f.endsWith(".md"));
               } catch {
                 continue;
               }
               for (const file of files) {
                 let raw;
                 try {
-                  raw = (0, import_node_fs7.readFileSync)((0, import_node_path21.join)(scopeDir, file), "utf-8");
+                  raw = (0, import_node_fs8.readFileSync)((0, import_node_path22.join)(scopeDir, file), "utf-8");
                 } catch {
                   continue;
                 }
@@ -823,25 +823,25 @@ ${lines.join("\n")}
           const tiers = ["products", "suites", "tests"];
           const toInsert = [];
           for (const tier of tiers) {
-            const tierDir = (0, import_node_path21.join)(this.memoryRoot, tier);
+            const tierDir = (0, import_node_path22.join)(this.memoryRoot, tier);
             let scopes;
             try {
-              scopes = (0, import_node_fs7.readdirSync)(tierDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+              scopes = (0, import_node_fs8.readdirSync)(tierDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
             } catch {
               continue;
             }
             for (const scope of scopes) {
-              const scopeDir = (0, import_node_path21.join)(tierDir, scope);
+              const scopeDir = (0, import_node_path22.join)(tierDir, scope);
               let files;
               try {
-                files = (0, import_node_fs7.readdirSync)(scopeDir).filter((f) => f.startsWith("obs_") && f.endsWith(".md"));
+                files = (0, import_node_fs8.readdirSync)(scopeDir).filter((f) => f.startsWith("obs_") && f.endsWith(".md"));
               } catch {
                 continue;
               }
               for (const file of files) {
                 let raw;
                 try {
-                  raw = (0, import_node_fs7.readFileSync)((0, import_node_path21.join)(scopeDir, file), "utf-8");
+                  raw = (0, import_node_fs8.readFileSync)((0, import_node_path22.join)(scopeDir, file), "utf-8");
                 } catch {
                   continue;
                 }
@@ -1068,6 +1068,7 @@ __export(index_exports, {
   findSecretTemplates: () => findSecretTemplates,
   findUnresolvedTemplates: () => findUnresolvedTemplates,
   flushAnalytics: () => flushAnalytics,
+  formatAppiumInstallGuidance: () => formatAppiumInstallGuidance,
   formatDiagnostics: () => formatDiagnostics,
   formatDiagnosticsPlain: () => formatDiagnosticsPlain,
   formatLogEntry: () => formatLogEntry,
@@ -1102,6 +1103,7 @@ __export(index_exports, {
   listObservations: () => listObservations,
   listProviders: () => listProviders,
   loadLLMAuthPlugins: () => loadLLMAuthPlugins,
+  localAppiumBinaryNames: () => localAppiumBinaryNames,
   mapMobileCapabilities: () => mapMobileCapabilities,
   mapWebCapabilities: () => mapWebCapabilities,
   mergeRunAttributes: () => mergeRunAttributes,
@@ -1128,6 +1130,7 @@ __export(index_exports, {
   resolveAnalyticsAgentProduct: () => resolveAnalyticsAgentProduct,
   resolveAnalyticsIdentity: () => resolveAnalyticsIdentity,
   resolveAnalyticsStandardProperties: () => resolveAnalyticsStandardProperties,
+  resolveAppiumExecutable: () => resolveAppiumExecutable,
   resolveBetterSqliteRebuildCommand: () => resolveBetterSqliteRebuildCommand,
   resolveFarmCredentials: () => resolveFarmCredentials,
   resolveFileReferences: () => resolveFileReferences,
@@ -4974,9 +4977,9 @@ function getHookCommand(runtime, entryFile) {
   }
 }
 async function checkDockerAvailable(dockerBin = DEFAULT_DOCKER_BIN) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     (0, import_node_child_process.execFile)(dockerBin, ["info", "--format", "{{.ID}}"], { timeout: 5e3 }, (err) => {
-      resolve7(!err);
+      resolve8(!err);
     });
   });
 }
@@ -5089,22 +5092,22 @@ function filterSecretVariables(variables, secretStore) {
   );
 }
 function imageExists(dockerBin, image) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     (0, import_node_child_process.execFile)(dockerBin, ["image", "inspect", image], { timeout: 1e4 }, (err) => {
-      resolve7(!err);
+      resolve8(!err);
     });
   });
 }
 function pullImage(dockerBin, image) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     (0, import_node_child_process.execFile)(dockerBin, ["pull", image], { timeout: 12e4 }, (err) => {
       if (err) reject(new Error(`Failed to pull image ${image}: ${err.message}`));
-      else resolve7();
+      else resolve8();
     });
   });
 }
 function execDocker(dockerBin, args, timeout) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     let stdout = "";
     let stderr = "";
     let resolved = false;
@@ -5114,11 +5117,11 @@ function execDocker(dockerBin, args, timeout) {
       stdout = out ?? "";
       stderr = errOut ?? "";
       if (err && "killed" in err && err.killed) {
-        resolve7({ stdout, stderr: `Hook timed out after ${timeout}ms`, exitCode: 124 });
+        resolve8({ stdout, stderr: `Hook timed out after ${timeout}ms`, exitCode: 124 });
         return;
       }
       const exitCode = err?.code ?? 0;
-      resolve7({ stdout, stderr, exitCode: typeof exitCode === "number" ? exitCode : 1 });
+      resolve8({ stdout, stderr, exitCode: typeof exitCode === "number" ? exitCode : 1 });
     });
   });
 }
@@ -7194,14 +7197,41 @@ function resolveMobileRunConfig(input) {
   };
 }
 
+// src/mobile/appium-executable.ts
+var import_node_fs2 = require("fs");
+var import_node_path8 = require("path");
+function localAppiumBinaryNames(platform = process.platform) {
+  return platform === "win32" ? ["appium.cmd", "appium.exe", "appium"] : ["appium"];
+}
+function resolveAppiumExecutable(opts = {}) {
+  const exists = opts.exists ?? import_node_fs2.existsSync;
+  const names = localAppiumBinaryNames(opts.platform ?? process.platform);
+  let current = (0, import_node_path8.resolve)(opts.cwd ?? process.cwd());
+  const root = (0, import_node_path8.parse)(current).root;
+  while (true) {
+    for (const name of names) {
+      const candidate = (0, import_node_path8.join)(current, "node_modules", ".bin", name);
+      if (exists(candidate)) {
+        return { command: candidate, source: "local" };
+      }
+    }
+    if (current === root) break;
+    current = (0, import_node_path8.dirname)(current);
+  }
+  return { command: "appium", source: "path" };
+}
+function formatAppiumInstallGuidance() {
+  return "Install Appium locally with `npm install -D appium` (or `pnpm add -D appium` / `yarn add -D appium`). If you prefer a machine-wide setup, use `npm install -g appium`.";
+}
+
 // src/auth/store.ts
 var import_promises7 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var import_node_os2 = require("os");
 function getAuthPath() {
   const xdg = process.env.XDG_DATA_HOME;
-  if (xdg) return (0, import_node_path8.join)(xdg, "agent-qa", "auth.json");
-  return (0, import_node_path8.join)((0, import_node_os2.homedir)(), ".agent-qa", "auth.json");
+  if (xdg) return (0, import_node_path9.join)(xdg, "agent-qa", "auth.json");
+  return (0, import_node_path9.join)((0, import_node_os2.homedir)(), ".agent-qa", "auth.json");
 }
 async function readAuth(path5) {
   const authPath = path5 ?? getAuthPath();
@@ -7216,7 +7246,7 @@ async function writeAuth(provider, credential, path5) {
   const authPath = path5 ?? getAuthPath();
   const store = await readAuth(authPath);
   store[provider] = credential;
-  await (0, import_promises7.mkdir)((0, import_node_path8.dirname)(authPath), { recursive: true });
+  await (0, import_promises7.mkdir)((0, import_node_path9.dirname)(authPath), { recursive: true });
   await (0, import_promises7.writeFile)(authPath, JSON.stringify(store, null, 2), { mode: 384 });
 }
 async function removeAuth(provider, path5) {
@@ -7394,17 +7424,17 @@ async function resolveLLMAuth(configName, llmConfig, authPath) {
 
 // src/auth/plugin-loader.ts
 var import_node_module = require("module");
-var import_node_fs2 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path10 = require("path");
 var import_node_url = require("url");
 var import_meta = {};
 var loadedDeclarations = /* @__PURE__ */ new Set();
 function findPackageJson(packageName, baseDir) {
-  let current = (0, import_node_path9.resolve)(baseDir);
+  let current = (0, import_node_path10.resolve)(baseDir);
   while (true) {
-    const candidate = (0, import_node_path9.resolve)(current, "node_modules", ...packageName.split("/"), "package.json");
-    if ((0, import_node_fs2.existsSync)(candidate)) return candidate;
-    const parent = (0, import_node_path9.dirname)(current);
+    const candidate = (0, import_node_path10.resolve)(current, "node_modules", ...packageName.split("/"), "package.json");
+    if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path10.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -7429,10 +7459,10 @@ function exportTargetFromPackageJson(pkg) {
 function resolvePackageImportFromBase(packageName, baseDir) {
   const packageJsonPath = findPackageJson(packageName, baseDir);
   if (!packageJsonPath) return null;
-  const pkg = JSON.parse((0, import_node_fs2.readFileSync)(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse((0, import_node_fs3.readFileSync)(packageJsonPath, "utf-8"));
   const target = exportTargetFromPackageJson(pkg);
   if (!target || !target.startsWith(".")) return null;
-  return (0, import_node_url.pathToFileURL)((0, import_node_path9.resolve)((0, import_node_path9.dirname)(packageJsonPath), target)).href;
+  return (0, import_node_url.pathToFileURL)((0, import_node_path10.resolve)((0, import_node_path10.dirname)(packageJsonPath), target)).href;
 }
 function packageDeclarationValue(declaration) {
   return "package" in declaration && typeof declaration.package === "string" ? declaration.package.trim() : "";
@@ -7443,24 +7473,24 @@ function pathDeclarationValue(declaration) {
 function declarationKey(declaration, baseDir) {
   const packageName = packageDeclarationValue(declaration);
   if (packageName) return `package:${packageName}`;
-  return `path:${(0, import_node_path9.resolve)(baseDir, pathDeclarationValue(declaration))}`;
+  return `path:${(0, import_node_path10.resolve)(baseDir, pathDeclarationValue(declaration))}`;
 }
 function resolveModuleSpecifier(declaration, baseDir) {
   const packageName = packageDeclarationValue(declaration);
   if (packageName) {
     const packageImport = resolvePackageImportFromBase(packageName, baseDir);
     if (packageImport) return packageImport;
-    const parentUrl = (0, import_node_url.pathToFileURL)((0, import_node_path9.resolve)(baseDir, "agent-qa.config.yaml")).href;
+    const parentUrl = (0, import_node_url.pathToFileURL)((0, import_node_path10.resolve)(baseDir, "agent-qa.config.yaml")).href;
     try {
       const resolveImport = import_meta.resolve;
       return resolveImport(packageName, parentUrl);
     } catch {
-      const require3 = (0, import_node_module.createRequire)((0, import_node_path9.resolve)(baseDir, "agent-qa.config.yaml"));
+      const require3 = (0, import_node_module.createRequire)((0, import_node_path10.resolve)(baseDir, "agent-qa.config.yaml"));
       return (0, import_node_url.pathToFileURL)(require3.resolve(packageName)).href;
     }
   }
   const pluginPath = pathDeclarationValue(declaration);
-  const absolutePath = (0, import_node_path9.isAbsolute)(pluginPath) ? pluginPath : (0, import_node_path9.resolve)(baseDir, pluginPath);
+  const absolutePath = (0, import_node_path10.isAbsolute)(pluginPath) ? pluginPath : (0, import_node_path10.resolve)(baseDir, pluginPath);
   return (0, import_node_url.pathToFileURL)(absolutePath).href;
 }
 async function resolvePluginBundle(module2, source) {
@@ -7850,8 +7880,8 @@ function mapMobileCapabilities(match, platform, credentials, opts) {
 }
 
 // src/farm/browserstack.ts
-var import_node_fs3 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path11 = require("path");
 function isAbsoluteAppValue(value) {
   return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 }
@@ -7870,9 +7900,9 @@ async function resolveBrowserStackApp(config) {
     });
   }
   const appBaseDir = config.appBaseDir ?? process.cwd();
-  const resolvedPath = (0, import_node_path10.resolve)(appBaseDir, config.app);
+  const resolvedPath = (0, import_node_path11.resolve)(appBaseDir, config.app);
   const mustExist = isExplicitRelativePath(config.app);
-  if (!(0, import_node_fs3.existsSync)(resolvedPath)) {
+  if (!(0, import_node_fs4.existsSync)(resolvedPath)) {
     if (mustExist) {
       throw new MobileSetupError({
         category: "app-install",
@@ -7886,7 +7916,7 @@ async function resolveBrowserStackApp(config) {
   }
   const auth = Buffer.from(`${config.credentials.username}:${config.credentials.accessKey}`).toString("base64");
   const form = new FormData();
-  form.append("file", new Blob([(0, import_node_fs3.readFileSync)(resolvedPath)]), (0, import_node_path10.basename)(resolvedPath));
+  form.append("file", new Blob([(0, import_node_fs4.readFileSync)(resolvedPath)]), (0, import_node_path11.basename)(resolvedPath));
   let res;
   try {
     res = await fetch("https://api-cloud.browserstack.com/app-automate/upload", {
@@ -8063,7 +8093,7 @@ async function runHooks(hooks, options = {}) {
 // src/memory/curator.ts
 var import_ai7 = require("ai");
 var import_zod19 = require("zod");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var import_promises9 = require("fs/promises");
 init_observation_io();
 
@@ -8212,7 +8242,7 @@ function collectKnownObservationIds(injectedObservationIds, dedupMatches) {
 async function findObservationFile(memoryRoot, id) {
   const tiers = ["products", "suites", "tests"];
   for (const tier of tiers) {
-    const tierDir = (0, import_node_path12.join)(memoryRoot, tier);
+    const tierDir = (0, import_node_path13.join)(memoryRoot, tier);
     let scopes;
     try {
       scopes = await (0, import_promises9.readdir)(tierDir);
@@ -8220,7 +8250,7 @@ async function findObservationFile(memoryRoot, id) {
       continue;
     }
     for (const scope of scopes) {
-      const filePath = (0, import_node_path12.join)(tierDir, scope, `${id}.md`);
+      const filePath = (0, import_node_path13.join)(tierDir, scope, `${id}.md`);
       try {
         await (0, import_promises9.access)(filePath);
         return { tier, scope, filePath };
@@ -8449,11 +8479,11 @@ ${userMessage}`;
       }
       if (ctx.suiteId && ctx.suiteContext) {
         try {
-          const suiteDir = (0, import_node_path12.join)(ctx.memoryRoot, "suites", ctx.suiteId);
+          const suiteDir = (0, import_node_path13.join)(ctx.memoryRoot, "suites", ctx.suiteId);
           const files = await listObservations(suiteDir);
           for (const file of files) {
             try {
-              const filePath = (0, import_node_path12.join)(suiteDir, file);
+              const filePath = (0, import_node_path13.join)(suiteDir, file);
               const raw = await (0, import_promises9.readFile)(filePath, "utf-8");
               const { data } = parseObservation(raw, file);
               if (!data || !("suite_snapshot" in data)) continue;
@@ -8917,6 +8947,7 @@ async function runSuite(suite, testEntries, config) {
           inlineHookSandboxOptions: config.sandboxOptions,
           secretStore: config.secretStore,
           secretRedactor: config.secretRedactor,
+          accessibility: config.accessibility,
           logCapture: config.logCapture,
           screenshotSize: config.screenshotSize,
           effectiveResolution: config.effectiveResolution,
@@ -8984,7 +9015,8 @@ async function runSuite(suite, testEntries, config) {
                       timeouts: config.timeouts,
                       logger: config.logger,
                       secretStore: config.secretStore,
-                      secretRedactor: config.secretRedactor
+                      secretRedactor: config.secretRedactor,
+                      accessibility: config.accessibility
                     }, filePath);
                     if (config.circuitBreaker) {
                       config.circuitBreaker.record({ withMemory: false, passed: ablationResult.status === "passed" });
@@ -9155,14 +9187,14 @@ async function runSuite(suite, testEntries, config) {
 
 // src/validation/validate.ts
 var import_promises12 = require("fs/promises");
-var import_node_fs5 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs6 = require("fs");
+var import_node_path17 = __toESM(require("path"), 1);
 var import_yaml5 = require("yaml");
 var import_glob2 = require("glob");
 
 // src/hooks/parser.ts
 var import_promises11 = require("fs/promises");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 var import_yaml4 = require("yaml");
 async function parseHooksFile(filePath) {
   let raw;
@@ -9184,31 +9216,31 @@ async function parseHooksFile(filePath) {
     );
     return { hooks: [], errors };
   }
-  const dir = (0, import_node_path13.dirname)(filePath);
+  const dir = (0, import_node_path14.dirname)(filePath);
   const hooks = result.data.hooks.map((h) => ({
     ...h,
-    file: (0, import_node_path13.resolve)(dir, h.file),
-    deps: h.deps.map((d) => (0, import_node_path13.resolve)(dir, d)),
-    packageFile: h.packageFile ? (0, import_node_path13.resolve)(dir, h.packageFile) : void 0
+    file: (0, import_node_path14.resolve)(dir, h.file),
+    deps: h.deps.map((d) => (0, import_node_path14.resolve)(dir, d)),
+    packageFile: h.packageFile ? (0, import_node_path14.resolve)(dir, h.packageFile) : void 0
   }));
   return { hooks, errors: [] };
 }
 
 // src/utils/path-validation.ts
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 function isPathInsideDir(childPath, parentDir) {
   if (!childPath) return false;
-  const resolved = import_node_path14.default.resolve(parentDir, childPath);
-  const relative2 = import_node_path14.default.relative(parentDir, resolved);
-  return !!relative2 && !relative2.startsWith("..") && !import_node_path14.default.isAbsolute(relative2);
+  const resolved = import_node_path15.default.resolve(parentDir, childPath);
+  const relative2 = import_node_path15.default.relative(parentDir, resolved);
+  return !!relative2 && !relative2.startsWith("..") && !import_node_path15.default.isAbsolute(relative2);
 }
 
 // src/workspace/workspace-paths.ts
-var import_node_fs4 = require("fs");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs5 = require("fs");
+var import_node_path16 = __toESM(require("path"), 1);
 var import_glob = require("glob");
 function toForwardSlash(value) {
-  return value.split(import_node_path15.default.sep).join("/");
+  return value.split(import_node_path16.default.sep).join("/");
 }
 function trimLeadingCurrentDir(value) {
   return toForwardSlash(value).replace(/^\.\//, "");
@@ -9227,16 +9259,16 @@ function assertNonEmptyString(value, key) {
 }
 function resolveWorkspaceScalar(configDir, key, configuredPath) {
   const value = assertNonEmptyString(configuredPath, key);
-  const absolutePath = import_node_path15.default.isAbsolute(value) ? import_node_path15.default.resolve(value) : import_node_path15.default.resolve(configDir, value);
+  const absolutePath = import_node_path16.default.isAbsolute(value) ? import_node_path16.default.resolve(value) : import_node_path16.default.resolve(configDir, value);
   return {
     configuredPath: value,
     absolutePath,
-    workspaceRelativePath: trimLeadingCurrentDir(import_node_path15.default.relative(configDir, absolutePath))
+    workspaceRelativePath: trimLeadingCurrentDir(import_node_path16.default.relative(configDir, absolutePath))
   };
 }
 function assertInsideWorkspace(configDir, absolutePath, filePath) {
-  const relativePath = import_node_path15.default.relative(configDir, absolutePath);
-  if (!relativePath || relativePath.startsWith("..") || import_node_path15.default.isAbsolute(relativePath)) {
+  const relativePath = import_node_path16.default.relative(configDir, absolutePath);
+  if (!relativePath || relativePath.startsWith("..") || import_node_path16.default.isAbsolute(relativePath)) {
     throw new Error(`Workspace file path escapes config directory: ${filePath}`);
   }
   return trimLeadingCurrentDir(relativePath);
@@ -9293,8 +9325,8 @@ function isIgnored(workspace, workspaceRelativePath) {
   return workspace.testPathIgnore.length > 0 && matchesAnyPattern(workspaceRelativePath, workspace.testPathIgnore);
 }
 function resolveWorkspacePaths(input) {
-  const configPath = import_node_path15.default.resolve(input.configPath);
-  const configDir = import_node_path15.default.dirname(configPath);
+  const configPath = import_node_path16.default.resolve(input.configPath);
+  const configDir = import_node_path16.default.dirname(configPath);
   const workspace = input.config.workspace;
   if (!workspace) {
     throw new Error("Missing required workspace config key: workspace");
@@ -9317,7 +9349,7 @@ function resolveWorkspacePaths(input) {
       ["workspace.envFile", resolved.envFile],
       ["workspace.secretsFile", resolved.secretsFile]
     ]) {
-      if (!(0, import_node_fs4.existsSync)(file.absolutePath)) {
+      if (!(0, import_node_fs5.existsSync)(file.absolutePath)) {
         throw new Error(`Configured workspace file not found: ${key} -> ${file.absolutePath}`);
       }
     }
@@ -9332,14 +9364,14 @@ async function discoverWorkspaceFiles(input) {
     absolute: true,
     nodir: true
   });
-  return matches.map((match) => import_node_path15.default.resolve(match)).map((absolutePath) => ({
+  return matches.map((match) => import_node_path16.default.resolve(match)).map((absolutePath) => ({
     kind: input.kind,
     absolutePath,
-    workspaceRelativePath: trimLeadingCurrentDir(import_node_path15.default.relative(input.workspace.configDir, absolutePath))
+    workspaceRelativePath: trimLeadingCurrentDir(import_node_path16.default.relative(input.workspace.configDir, absolutePath))
   })).sort((a, b) => a.workspaceRelativePath.localeCompare(b.workspaceRelativePath));
 }
 async function resolveWorkspaceFileTarget(input) {
-  const absolutePath = import_node_path15.default.isAbsolute(input.filePath) ? import_node_path15.default.resolve(input.filePath) : import_node_path15.default.resolve(input.workspace.configDir, input.filePath);
+  const absolutePath = import_node_path16.default.isAbsolute(input.filePath) ? import_node_path16.default.resolve(input.filePath) : import_node_path16.default.resolve(input.workspace.configDir, input.filePath);
   const workspaceRelativePath = assertInsideWorkspace(input.workspace.configDir, absolutePath, input.filePath);
   if (!isWorkspacePathMatch({
     workspace: input.workspace,
@@ -9348,7 +9380,7 @@ async function resolveWorkspaceFileTarget(input) {
   })) {
     throw new Error(`Workspace ${input.kind} file is not matched by configured workspace patterns: ${workspaceRelativePath}`);
   }
-  if (input.requireExisting && !(0, import_node_fs4.existsSync)(absolutePath)) {
+  if (input.requireExisting && !(0, import_node_fs5.existsSync)(absolutePath)) {
     throw new Error(`Workspace ${input.kind} file not found: ${workspaceRelativePath}`);
   }
   return {
@@ -9469,8 +9501,8 @@ function validateSuiteFile(filePath, content, basedir) {
       });
       continue;
     }
-    const resolved = import_node_path16.default.resolve(basedir, testPath);
-    if (!(0, import_node_fs5.existsSync)(resolved)) {
+    const resolved = import_node_path17.default.resolve(basedir, testPath);
+    if (!(0, import_node_fs6.existsSync)(resolved)) {
       let line = 1;
       let column = 1;
       const seqNode = testsNode;
@@ -9491,7 +9523,7 @@ function validateSuiteFile(filePath, content, basedir) {
   return diagnostics;
 }
 function validateFilename(filePath) {
-  const basename3 = import_node_path16.default.basename(filePath);
+  const basename3 = import_node_path17.default.basename(filePath);
   if (!VALID_FILENAME_RE.test(basename3)) {
     return [{
       file: filePath,
@@ -9505,7 +9537,7 @@ function validateFilename(filePath) {
 }
 async function validateHooksFile(hooksFilePath, options = {}) {
   const diagnostics = [];
-  if (!(0, import_node_fs5.existsSync)(hooksFilePath)) {
+  if (!(0, import_node_fs6.existsSync)(hooksFilePath)) {
     if (options.required) {
       return [buildDiagnostic(hooksFilePath, `Configured hooks file not found: ${hooksFilePath}`)];
     }
@@ -9525,7 +9557,7 @@ async function validateHooksFile(hooksFilePath, options = {}) {
     return diagnostics;
   }
   for (const hook of hooks) {
-    if (!(0, import_node_fs5.existsSync)(hook.file)) {
+    if (!(0, import_node_fs6.existsSync)(hook.file)) {
       diagnostics.push({
         file: hooksFilePath,
         line: 1,
@@ -9535,7 +9567,7 @@ async function validateHooksFile(hooksFilePath, options = {}) {
       });
     }
     for (const dep of hook.deps) {
-      if (!(0, import_node_fs5.existsSync)(dep)) {
+      if (!(0, import_node_fs6.existsSync)(dep)) {
         diagnostics.push({
           file: hooksFilePath,
           line: 1,
@@ -9545,7 +9577,7 @@ async function validateHooksFile(hooksFilePath, options = {}) {
         });
       }
     }
-    if (hook.packageFile && !(0, import_node_fs5.existsSync)(hook.packageFile)) {
+    if (hook.packageFile && !(0, import_node_fs6.existsSync)(hook.packageFile)) {
       diagnostics.push({
         file: hooksFilePath,
         line: 1,
@@ -9660,7 +9692,7 @@ function validateRequiredWorkspaceFiles(workspace) {
     ["workspace.envFile", workspace.envFile],
     ["workspace.secretsFile", workspace.secretsFile]
   ]) {
-    if (!(0, import_node_fs5.existsSync)(file.absolutePath)) {
+    if (!(0, import_node_fs6.existsSync)(file.absolutePath)) {
       diagnostics.push(buildDiagnostic(file.absolutePath, `Configured workspace file not found: ${key} -> ${file.absolutePath}`));
     }
   }
@@ -9678,7 +9710,7 @@ async function validateProject(options = {}) {
     }
     filePaths = resolvedFiles;
   } else if (options.files && options.files.length > 0) {
-    filePaths = options.files.map((f) => import_node_path16.default.resolve(f));
+    filePaths = options.files.map((f) => import_node_path17.default.resolve(f));
   } else if (options.workspace) {
     const [testFiles, suiteFiles] = await Promise.all([
       discoverWorkspaceFiles({ workspace: options.workspace, kind: "test" }),
@@ -9721,11 +9753,11 @@ async function validateProject(options = {}) {
     if (d.severity === "error") result.errorCount++;
     else result.warningCount++;
   }
-  if (hooksFilePath && hooksDiags.length === 0 && (0, import_node_fs5.existsSync)(hooksFilePath)) {
+  if (hooksFilePath && hooksDiags.length === 0 && (0, import_node_fs6.existsSync)(hooksFilePath)) {
     const { hooks } = await parseHooksFile(hooksFilePath);
     const hookIds = new Set(hooks.map((h) => h.id));
     for (const filePath of filePaths) {
-      const workspaceRelativePath = options.workspace ? import_node_path16.default.relative(options.workspace.configDir, filePath).split(import_node_path16.default.sep).join("/") : filePath;
+      const workspaceRelativePath = options.workspace ? import_node_path17.default.relative(options.workspace.configDir, filePath).split(import_node_path17.default.sep).join("/") : filePath;
       const isWorkspaceFile = options.workspace ? isWorkspacePathMatch({ workspace: options.workspace, kind: isSuiteFile(filePath) ? "suite" : "test", workspaceRelativePath }) : true;
       if (!isWorkspaceFile) continue;
       try {
@@ -9827,7 +9859,7 @@ function warnIfOutOfBounds(coords, viewport, actionType) {
 
 // src/hooks/migrate-hook-refs.ts
 var import_promises13 = require("fs/promises");
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 var import_yaml6 = require("yaml");
 var import_zod20 = require("zod");
 var import_agent_qa_ids8 = require("@vostride/agent-qa-ids");
@@ -9933,7 +9965,7 @@ function rewriteSteps(owner, filePath, hookNameToId, hookIds, errors) {
   return changed;
 }
 async function resolveWorkspaceMigrationContext(workspaceDir, configPath) {
-  const resolvedConfigPath = configPath ? (0, import_node_path17.resolve)(configPath) : (0, import_node_path17.resolve)(workspaceDir, "agent-qa.config.yaml");
+  const resolvedConfigPath = configPath ? (0, import_node_path18.resolve)(configPath) : (0, import_node_path18.resolve)(workspaceDir, "agent-qa.config.yaml");
   const rawConfig = await (0, import_promises13.readFile)(resolvedConfigPath, "utf-8");
   const parsedConfig = (0, import_yaml6.parse)(rawConfig);
   const configResult = AgentQaConfigSchema.safeParse(parsedConfig);
@@ -9960,7 +9992,7 @@ async function resolveWorkspaceMigrationContext(workspaceDir, configPath) {
   };
 }
 async function auditWorkspaceHookReferenceMigration(options) {
-  const workspaceDir = (0, import_node_path17.resolve)(options.workspaceDir);
+  const workspaceDir = (0, import_node_path18.resolve)(options.workspaceDir);
   const errors = [];
   let context;
   try {
@@ -10023,12 +10055,12 @@ async function auditWorkspaceHookReferenceMigration(options) {
   const hookIds = new Set(Object.values(hookNameToId));
   if (hooksChanged) {
     rewriteFiles.push({
-      path: (0, import_node_path17.relative)(context.configDir, context.hooksFilePath),
+      path: (0, import_node_path18.relative)(context.configDir, context.hooksFilePath),
       content: (0, import_yaml6.stringify)({ hooks: normalizedHooks })
     });
   }
   for (const relativePath of context.targetFiles) {
-    const absolutePath = (0, import_node_path17.resolve)(context.configDir, relativePath);
+    const absolutePath = (0, import_node_path18.resolve)(context.configDir, relativePath);
     let parsedFile;
     try {
       parsedFile = (0, import_yaml6.parse)(await (0, import_promises13.readFile)(absolutePath, "utf-8"));
@@ -10069,14 +10101,14 @@ async function applyWorkspaceHookReferenceMigration(options) {
   if (!audit.ok) {
     throw new HookReferenceMigrationError(audit.errors);
   }
-  const workspaceDir = options.configPath ? (0, import_node_path17.dirname)((0, import_node_path17.resolve)(options.configPath)) : (0, import_node_path17.resolve)(options.workspaceDir);
+  const workspaceDir = options.configPath ? (0, import_node_path18.dirname)((0, import_node_path18.resolve)(options.configPath)) : (0, import_node_path18.resolve)(options.workspaceDir);
   for (const rewrite of audit.rewriteFiles) {
-    const outputPath = (0, import_node_path17.resolve)(workspaceDir, rewrite.path);
-    await (0, import_promises13.mkdir)((0, import_node_path17.dirname)(outputPath), { recursive: true });
+    const outputPath = (0, import_node_path18.resolve)(workspaceDir, rewrite.path);
+    await (0, import_promises13.mkdir)((0, import_node_path18.dirname)(outputPath), { recursive: true });
     await (0, import_promises13.writeFile)(outputPath, rewrite.content, "utf-8");
   }
   for (const cleanupTarget of audit.cleanupTargets) {
-    await (0, import_promises13.rm)((0, import_node_path17.resolve)(workspaceDir, cleanupTarget), { recursive: true, force: true });
+    await (0, import_promises13.rm)((0, import_node_path18.resolve)(workspaceDir, cleanupTarget), { recursive: true, force: true });
   }
   return audit;
 }
@@ -10147,12 +10179,12 @@ var RUN_ARTIFACT_SCHEMA_VERSION = 1;
 // src/analytics/identity.ts
 var import_promises17 = require("fs/promises");
 var import_node_os4 = require("os");
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 var import_id_agent = require("id-agent");
 var LOCAL_ANALYTICS_ID_PATTERN = /^u_([a-z]+-){9}[a-z]+$/;
 function getAnalyticsIdentityPath(env = process.env, homeDir = (0, import_node_os4.homedir)()) {
-  if (env.XDG_DATA_HOME) return (0, import_node_path22.join)(env.XDG_DATA_HOME, "agent-qa", "analytics.json");
-  return (0, import_node_path22.join)(homeDir, ".agent-qa", "analytics.json");
+  if (env.XDG_DATA_HOME) return (0, import_node_path23.join)(env.XDG_DATA_HOME, "agent-qa", "analytics.json");
+  return (0, import_node_path23.join)(homeDir, ".agent-qa", "analytics.json");
 }
 function generateAnalyticsUserId() {
   return (0, import_id_agent.idAgent)({ prefix: "u", words: 10 });
@@ -10184,7 +10216,7 @@ async function readAnalyticsIdentity(path5) {
 }
 async function writeAnalyticsIdentity(distinctId, path5, isInternal = false) {
   const identityPath = path5 ?? getAnalyticsIdentityPath();
-  await (0, import_promises17.mkdir)((0, import_node_path22.dirname)(identityPath), { recursive: true });
+  await (0, import_promises17.mkdir)((0, import_node_path23.dirname)(identityPath), { recursive: true });
   await (0, import_promises17.writeFile)(identityPath, JSON.stringify({
     distinctId,
     is_internal: isInternal
@@ -11295,6 +11327,7 @@ function isMacPlatform() {
   findSecretTemplates,
   findUnresolvedTemplates,
   flushAnalytics,
+  formatAppiumInstallGuidance,
   formatDiagnostics,
   formatDiagnosticsPlain,
   formatLogEntry,
@@ -11329,6 +11362,7 @@ function isMacPlatform() {
   listObservations,
   listProviders,
   loadLLMAuthPlugins,
+  localAppiumBinaryNames,
   mapMobileCapabilities,
   mapWebCapabilities,
   mergeRunAttributes,
@@ -11355,6 +11389,7 @@ function isMacPlatform() {
   resolveAnalyticsAgentProduct,
   resolveAnalyticsIdentity,
   resolveAnalyticsStandardProperties,
+  resolveAppiumExecutable,
   resolveBetterSqliteRebuildCommand,
   resolveFarmCredentials,
   resolveFileReferences,