@vostride/agent-qa-core 0.1.14 → 0.1.16

package/dist/index.cjs

@@ -45,43 +45,43 @@ var init_config = __esm({
 });
 
 // src/memory/schema.ts
-var import_zod18, import_agent_qa_ids5, ObservationIdSchema, CanonicalObservationIdSchema, ObservationSuiteSnapshotEntrySchema, BaseObservationSchema, SuiteObservationSchema, BaseObservationWriteSchema, SuiteObservationWriteSchema;
+var import_zod19, import_agent_qa_ids5, ObservationIdSchema, CanonicalObservationIdSchema, ObservationSuiteSnapshotEntrySchema, BaseObservationSchema, SuiteObservationSchema, BaseObservationWriteSchema, SuiteObservationWriteSchema;
 var init_schema = __esm({
   "src/memory/schema.ts"() {
     "use strict";
-    import_zod18 = require("zod");
+    import_zod19 = require("zod");
     import_agent_qa_ids5 = require("@vostride/agent-qa-ids");
-    ObservationIdSchema = import_zod18.z.string().refine((value) => (0, import_agent_qa_ids5.isObservationId)(value), {
+    ObservationIdSchema = import_zod19.z.string().refine((value) => (0, import_agent_qa_ids5.isObservationId)(value), {
       message: "Observation ID must be obs_ followed by either 10 canonical words or a legacy 6-word body"
     });
-    CanonicalObservationIdSchema = import_zod18.z.string().refine((value) => (0, import_agent_qa_ids5.isCanonicalObservationId)(value), {
+    CanonicalObservationIdSchema = import_zod19.z.string().refine((value) => (0, import_agent_qa_ids5.isCanonicalObservationId)(value), {
       message: "Observation ID must be obs_ followed by 10 id-agent words"
     });
-    ObservationSuiteSnapshotEntrySchema = import_zod18.z.object({
-      test: import_zod18.z.string(),
-      id: import_zod18.z.string()
+    ObservationSuiteSnapshotEntrySchema = import_zod19.z.object({
+      test: import_zod19.z.string(),
+      id: import_zod19.z.string()
     }).strict();
-    BaseObservationSchema = import_zod18.z.object({
+    BaseObservationSchema = import_zod19.z.object({
       id: ObservationIdSchema,
-      title: import_zod18.z.string().min(1),
-      content: import_zod18.z.string().min(1),
-      trust: import_zod18.z.number().min(0).max(1),
-      created: import_zod18.z.string().datetime(),
-      last_confirmed: import_zod18.z.string().datetime(),
-      confirmed_count: import_zod18.z.number().int().min(0),
-      contradicted_count: import_zod18.z.number().int().min(0),
-      source_test: import_zod18.z.string().min(1)
+      title: import_zod19.z.string().min(1),
+      content: import_zod19.z.string().min(1),
+      trust: import_zod19.z.number().min(0).max(1),
+      created: import_zod19.z.string().datetime(),
+      last_confirmed: import_zod19.z.string().datetime(),
+      confirmed_count: import_zod19.z.number().int().min(0),
+      contradicted_count: import_zod19.z.number().int().min(0),
+      source_test: import_zod19.z.string().min(1)
     }).strip();
     SuiteObservationSchema = BaseObservationSchema.extend({
-      position: import_zod18.z.number().int().min(0),
-      suite_snapshot: import_zod18.z.array(ObservationSuiteSnapshotEntrySchema).min(1)
+      position: import_zod19.z.number().int().min(0),
+      suite_snapshot: import_zod19.z.array(ObservationSuiteSnapshotEntrySchema).min(1)
     }).strip();
     BaseObservationWriteSchema = BaseObservationSchema.extend({
       id: CanonicalObservationIdSchema
     }).strip();
     SuiteObservationWriteSchema = BaseObservationWriteSchema.extend({
-      position: import_zod18.z.number().int().min(0),
-      suite_snapshot: import_zod18.z.array(ObservationSuiteSnapshotEntrySchema).min(1)
+      position: import_zod19.z.number().int().min(0),
+      suite_snapshot: import_zod19.z.array(ObservationSuiteSnapshotEntrySchema).min(1)
     }).strip();
   }
 });
@@ -93,26 +93,26 @@ function toObservationFrontmatter(data) {
 }
 async function ensureMemoryDirs(root) {
   await Promise.all(
-    MEMORY_TIERS.map((tier) => (0, import_promises8.mkdir)((0, import_node_path12.join)(root, tier), { recursive: true }))
+    MEMORY_TIERS.map((tier) => (0, import_promises10.mkdir)((0, import_node_path14.join)(root, tier), { recursive: true }))
   );
 }
 async function writeObservation(root, tier, scope, data) {
-  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)) {
+  const dir = (0, import_node_path14.join)(root, tier, scope);
+  const resolved = (0, import_node_path14.resolve)(dir);
+  const boundary = (0, import_node_path14.resolve)(root);
+  if (!resolved.startsWith(boundary + import_node_path14.sep)) {
     throw new Error(`Scope "${scope}" escapes memory root`);
   }
   const schema = "position" in data ? SuiteObservationWriteSchema : BaseObservationWriteSchema;
   const validated = schema.parse(data);
   const frontmatter = toObservationFrontmatter(validated);
-  await (0, import_promises8.mkdir)(dir, { recursive: true });
+  await (0, import_promises10.mkdir)(dir, { recursive: true });
   const content = `---
 ${(0, import_yaml3.stringify)({ ...frontmatter }, { lineWidth: 0 })}---
 ${validated.content}
 `;
-  const filePath = (0, import_node_path12.join)(dir, `${data.id}.md`);
-  await (0, import_promises8.writeFile)(filePath, content, "utf-8");
+  const filePath = (0, import_node_path14.join)(dir, `${data.id}.md`);
+  await (0, import_promises10.writeFile)(filePath, content, "utf-8");
   return filePath;
 }
 function parseObservation(content, filename) {
@@ -149,7 +149,7 @@ function parseObservation(content, filename) {
 async function listObservations(dir) {
   let entries;
   try {
-    entries = await (0, import_promises8.readdir)(dir);
+    entries = await (0, import_promises10.readdir)(dir);
   } catch (e) {
     if (e instanceof Error && "code" in e && e.code === "ENOENT") {
       return [];
@@ -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_path12, MEMORY_TIERS;
+var import_yaml3, import_promises10, import_node_path14, 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_path12 = require("path");
+    import_promises10 = require("fs/promises");
+    import_node_path14 = require("path");
     init_schema();
     MEMORY_TIERS = ["products", "suites", "tests"];
   }
@@ -238,13 +238,13 @@ function isBetterSqlite3NodeGypSymlinkConflict(error) {
   return message.includes("node_gyp_bins/python3") && message.includes("EEXIST");
 }
 function resolveCurrentRuntimeNpmCliPath() {
-  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");
+  const nodeInstallRoot = (0, import_node_path21.dirname)((0, import_node_path21.dirname)(process.execPath));
+  const npmCliPath = (0, import_node_path21.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_path19.dirname)((0, import_node_path19.dirname)(process.execPath));
-  const nodeHeaderPath = (0, import_node_path19.join)(nodeInstallRoot, "include", "node", "node.h");
+  const nodeInstallRoot = (0, import_node_path21.dirname)((0, import_node_path21.dirname)(process.execPath));
+  const nodeHeaderPath = (0, import_node_path21.join)(nodeInstallRoot, "include", "node", "node.h");
   return (0, import_node_fs7.existsSync)(nodeHeaderPath) ? nodeInstallRoot : null;
 }
 function resolveBetterSqliteRebuildCommand() {
@@ -266,7 +266,7 @@ function sleepSync(milliseconds) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
 }
 function waitForBetterSqlite3BuildOutput(installRoot, timeoutMs = 3e4) {
-  const bindingPath = (0, import_node_path19.join)(installRoot, "build", "Release", "better_sqlite3.node");
+  const bindingPath = (0, import_node_path21.join)(installRoot, "build", "Release", "better_sqlite3.node");
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if ((0, import_node_fs7.existsSync)(bindingPath)) {
@@ -277,15 +277,15 @@ function waitForBetterSqlite3BuildOutput(installRoot, timeoutMs = 3e4) {
   return (0, import_node_fs7.existsSync)(bindingPath);
 }
 function acquireBetterSqlite3RebuildLock(installRoot) {
-  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_path19.join)(lockRoot, lockKey);
+  const lockRoot = (0, import_node_path21.join)((0, import_node_os3.tmpdir)(), "agent-qa-better-sqlite3-rebuild-locks");
+  const lockKey = (0, import_node_crypto7.createHash)("sha256").update(`${installRoot}\0${process.version}`).digest("hex");
+  const lockDir = (0, import_node_path21.join)(lockRoot, lockKey);
   const deadline = Date.now() + 12e4;
   (0, import_node_fs7.mkdirSync)(lockRoot, { recursive: true });
   while (true) {
     try {
       (0, import_node_fs7.mkdirSync)(lockDir);
-      (0, import_node_fs7.writeFileSync)((0, import_node_path19.join)(lockDir, "owner"), `${process.pid}
+      (0, import_node_fs7.writeFileSync)((0, import_node_path21.join)(lockDir, "owner"), `${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 ${installRoot}
 `);
@@ -314,13 +314,13 @@ function rebuildBetterSqlite3ForCurrentRuntime(originalError) {
   }
   rebuildAttempted = true;
   const packageJsonPath = require2.resolve("better-sqlite3/package.json");
-  const installRoot = (0, import_node_path19.dirname)(packageJsonPath);
+  const installRoot = (0, import_node_path21.dirname)(packageJsonPath);
   const rebuildCommand = resolveBetterSqliteRebuildCommand();
-  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 nodeGypDevDir = (0, import_node_path21.join)((0, import_node_os3.tmpdir)(), "agent-qa-node-gyp", process.version.replace(/^v/, ""));
+  const npmCacheDir = (0, import_node_path21.join)((0, import_node_os3.tmpdir)(), "agent-qa-npm-cache");
   const nodeDir = resolveCurrentRuntimeNodeDir();
-  const nodeGypBinsPath = (0, import_node_path19.join)(installRoot, "build", "node_gyp_bins");
-  const buildRoot = (0, import_node_path19.join)(installRoot, "build");
+  const nodeGypBinsPath = (0, import_node_path21.join)(installRoot, "build", "node_gyp_bins");
+  const buildRoot = (0, import_node_path21.join)(installRoot, "build");
   const releaseLock = acquireBetterSqlite3RebuildLock(installRoot);
   try {
     clearBetterSqlite3Cache();
@@ -375,31 +375,31 @@ function loadBetterSqlite3() {
   sqliteConstructor = require2("better-sqlite3");
   return sqliteConstructor;
 }
-function openBetterSqlite3Database(path5) {
+function openBetterSqlite3Database(path7) {
   const Database = loadBetterSqlite3();
-  return new Database(path5);
+  return new Database(path7);
 }
-function createBetterSqlite3Database(path5) {
+function createBetterSqlite3Database(path7) {
   try {
-    return openBetterSqlite3Database(path5);
+    return openBetterSqlite3Database(path7);
   } catch (error) {
     if (!isBetterSqlite3NativeModuleError(error)) {
       throw error;
     }
     rebuildBetterSqlite3ForCurrentRuntime(error);
-    return openBetterSqlite3Database(path5);
+    return openBetterSqlite3Database(path7);
   }
 }
-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 import_node_child_process2, import_node_fs7, import_node_crypto7, import_node_module3, import_node_os3, import_node_path21, import_meta3, require2, sqliteConstructor, rebuildAttempted, rebuildFailureMessage;
 var init_sqlite = __esm({
   "src/sqlite.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
     import_node_fs7 = require("fs");
-    import_node_crypto6 = require("crypto");
+    import_node_crypto7 = require("crypto");
     import_node_module3 = require("module");
     import_node_os3 = require("os");
-    import_node_path19 = require("path");
+    import_node_path21 = 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_path20.join)(params.memoryRoot, "products", params.product), isSuite: false });
+      dirs.push({ path: (0, import_node_path22.join)(params.memoryRoot, "products", params.product), isSuite: false });
     }
     if (params.suiteId && validatePathComponent(params.suiteId)) {
-      dirs.push({ path: (0, import_node_path20.join)(params.memoryRoot, "suites", params.suiteId), isSuite: true });
+      dirs.push({ path: (0, import_node_path22.join)(params.memoryRoot, "suites", params.suiteId), isSuite: true });
     }
     if (validatePathComponent(params.testId)) {
-      dirs.push({ path: (0, import_node_path20.join)(params.memoryRoot, "tests", params.testId), isSuite: false });
+      dirs.push({ path: (0, import_node_path22.join)(params.memoryRoot, "tests", params.testId), isSuite: false });
     }
     if (dirs.length === 0) {
       console.warn("[memory-index] All path components failed validation", {
@@ -455,10 +455,10 @@ 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_path20.join)(dirPath, filename);
+        const filePath = (0, import_node_path22.join)(dirPath, filename);
         let raw;
         try {
-          raw = await (0, import_promises14.readFile)(filePath, "utf-8");
+          raw = await (0, import_promises16.readFile)(filePath, "utf-8");
         } catch {
           continue;
         }
@@ -485,12 +485,12 @@ async function buildMemoryIndex(params) {
     return null;
   }
 }
-var import_promises14, import_node_path20;
+var import_promises16, import_node_path22;
 var init_memory_index = __esm({
   "src/memory/memory-index.ts"() {
     "use strict";
-    import_promises14 = require("fs/promises");
-    import_node_path20 = require("path");
+    import_promises16 = require("fs/promises");
+    import_node_path22 = 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_path21, LockManager;
+var import_promises17, import_node_path23, LockManager;
 var init_lock_manager = __esm({
   "src/memory/lock-manager.ts"() {
     "use strict";
-    import_promises15 = require("fs/promises");
-    import_node_path21 = require("path");
+    import_promises17 = require("fs/promises");
+    import_node_path23 = require("path");
     LockManager = class {
       lockPath;
       timeout;
@@ -522,17 +522,17 @@ var init_lock_manager = __esm({
         this.timeout = timeout;
       }
       async acquire() {
-        await (0, import_promises15.mkdir)((0, import_node_path21.dirname)(this.lockPath), { recursive: true });
+        await (0, import_promises17.mkdir)((0, import_node_path23.dirname)(this.lockPath), { recursive: true });
         const deadline = Date.now() + this.timeout;
         while (Date.now() < deadline) {
           try {
-            await (0, import_promises15.writeFile)(
+            await (0, import_promises17.writeFile)(
               this.lockPath,
               JSON.stringify({ pid: process.pid, timestamp: (/* @__PURE__ */ new Date()).toISOString() }),
               { flag: "wx" }
             );
             try {
-              const raw = await (0, import_promises15.readFile)(this.lockPath, "utf-8");
+              const raw = await (0, import_promises17.readFile)(this.lockPath, "utf-8");
               const { pid } = JSON.parse(raw);
               if (pid === process.pid) return;
             } catch {
@@ -541,7 +541,7 @@ var init_lock_manager = __esm({
           } catch (err) {
             if (err instanceof Error && "code" in err && err.code === "EEXIST") {
               if (await this.isStale()) {
-                await (0, import_promises15.unlink)(this.lockPath).catch(() => {
+                await (0, import_promises17.unlink)(this.lockPath).catch(() => {
                 });
                 continue;
               }
@@ -556,7 +556,7 @@ var init_lock_manager = __esm({
       async release() {
         let raw;
         try {
-          raw = await (0, import_promises15.readFile)(this.lockPath, "utf-8");
+          raw = await (0, import_promises17.readFile)(this.lockPath, "utf-8");
         } catch (err) {
           if (err instanceof Error && "code" in err && err.code === "ENOENT") {
             return;
@@ -567,19 +567,19 @@ var init_lock_manager = __esm({
         try {
           ({ pid } = JSON.parse(raw));
         } catch {
-          await (0, import_promises15.unlink)(this.lockPath).catch(() => {
+          await (0, import_promises17.unlink)(this.lockPath).catch(() => {
           });
           return;
         }
         if (pid === process.pid) {
-          await (0, import_promises15.unlink)(this.lockPath).catch(() => {
+          await (0, import_promises17.unlink)(this.lockPath).catch(() => {
           });
         }
       }
       async isStale() {
         let raw;
         try {
-          raw = await (0, import_promises15.readFile)(this.lockPath, "utf-8");
+          raw = await (0, import_promises17.readFile)(this.lockPath, "utf-8");
         } catch (err) {
           if (err instanceof Error && "code" in err && err.code === "ENOENT") {
             return true;
@@ -654,13 +654,13 @@ var local_provider_exports = {};
 __export(local_provider_exports, {
   LocalMemoryProvider: () => LocalMemoryProvider
 });
-var import_node_path22, import_node_fs8, import_promises16, LocalMemoryProvider;
+var import_node_path24, import_node_fs8, import_promises18, LocalMemoryProvider;
 var init_local_provider = __esm({
   "src/memory/local-provider.ts"() {
     "use strict";
-    import_node_path22 = require("path");
+    import_node_path24 = require("path");
     import_node_fs8 = require("fs");
-    import_promises16 = require("fs/promises");
+    import_promises18 = require("fs/promises");
     init_memory_index();
     init_xml_escape();
     init_lock_manager();
@@ -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_path22.join)(this.memoryRoot, ".curator.lock"),
+          (0, import_node_path24.join)(this.memoryRoot, ".curator.lock"),
           opts?.curatorLockTimeout ?? 12e4
         );
       }
@@ -751,13 +751,13 @@ ${lines.join("\n")}
         return writeObservation(this.memoryRoot, tier, scope, data);
       }
       async deleteObservation(tier, scope, id) {
-        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)) {
+        const filePath = (0, import_node_path24.join)(this.memoryRoot, tier, scope, `${id}.md`);
+        const resolved = (0, import_node_path24.resolve)(filePath);
+        if (!resolved.startsWith((0, import_node_path24.resolve)(this.memoryRoot) + import_node_path24.sep)) {
           throw new Error("Path escapes memory root");
         }
         try {
-          await (0, import_promises16.unlink)(filePath);
+          await (0, import_promises18.unlink)(filePath);
         } catch (err) {
           if (err instanceof Error && "code" in err && err.code === "ENOENT") {
             return;
@@ -770,7 +770,7 @@ ${lines.join("\n")}
           const results = [];
           const tiers = ["products", "suites", "tests"];
           for (const tier of tiers) {
-            const tierDir = (0, import_node_path22.join)(this.memoryRoot, tier);
+            const tierDir = (0, import_node_path24.join)(this.memoryRoot, tier);
             let scopes;
             try {
               scopes = (0, import_node_fs8.readdirSync)(tierDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -778,7 +778,7 @@ ${lines.join("\n")}
               continue;
             }
             for (const scope of scopes) {
-              const scopeDir = (0, import_node_path22.join)(tierDir, scope);
+              const scopeDir = (0, import_node_path24.join)(tierDir, scope);
               let files;
               try {
                 files = (0, import_node_fs8.readdirSync)(scopeDir).filter((f) => f.startsWith("obs_") && f.endsWith(".md"));
@@ -788,7 +788,7 @@ ${lines.join("\n")}
               for (const file of files) {
                 let raw;
                 try {
-                  raw = (0, import_node_fs8.readFileSync)((0, import_node_path22.join)(scopeDir, file), "utf-8");
+                  raw = (0, import_node_fs8.readFileSync)((0, import_node_path24.join)(scopeDir, file), "utf-8");
                 } catch {
                   continue;
                 }
@@ -823,7 +823,7 @@ ${lines.join("\n")}
           const tiers = ["products", "suites", "tests"];
           const toInsert = [];
           for (const tier of tiers) {
-            const tierDir = (0, import_node_path22.join)(this.memoryRoot, tier);
+            const tierDir = (0, import_node_path24.join)(this.memoryRoot, tier);
             let scopes;
             try {
               scopes = (0, import_node_fs8.readdirSync)(tierDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -831,7 +831,7 @@ ${lines.join("\n")}
               continue;
             }
             for (const scope of scopes) {
-              const scopeDir = (0, import_node_path22.join)(tierDir, scope);
+              const scopeDir = (0, import_node_path24.join)(tierDir, scope);
               let files;
               try {
                 files = (0, import_node_fs8.readdirSync)(scopeDir).filter((f) => f.startsWith("obs_") && f.endsWith(".md"));
@@ -841,7 +841,7 @@ ${lines.join("\n")}
               for (const file of files) {
                 let raw;
                 try {
-                  raw = (0, import_node_fs8.readFileSync)((0, import_node_path22.join)(scopeDir, file), "utf-8");
+                  raw = (0, import_node_fs8.readFileSync)((0, import_node_path24.join)(scopeDir, file), "utf-8");
                 } catch {
                   continue;
                 }
@@ -920,6 +920,14 @@ __export(index_exports, {
   ANDROID_ROLE_MAP: () => ANDROID_ROLE_MAP,
   ATTR_RUNNER: () => ATTR_RUNNER,
   ATTR_TRIGGER: () => ATTR_TRIGGER,
+  AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH: () => AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH,
+  AUTH_STATE_HOOK_JSON_ENV: () => AUTH_STATE_HOOK_JSON_ENV,
+  AUTH_STATE_HOOK_STORAGE_STATE_FILENAME: () => AUTH_STATE_HOOK_STORAGE_STATE_FILENAME,
+  AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV: () => AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV,
+  AUTH_STATE_HOOK_WORKSPACE_DIR: () => AUTH_STATE_HOOK_WORKSPACE_DIR,
+  AUTH_STATE_REDACTION_MARKER: () => AUTH_STATE_REDACTION_MARKER,
+  AUTH_STATE_SCHEMA_VERSION: () => AUTH_STATE_SCHEMA_VERSION,
+  AUTH_STATE_SLUG_PATTERN: () => AUTH_STATE_SLUG_PATTERN,
   AccessibilityConfigSchema: () => AccessibilityConfigSchema,
   ActionPlanSchema: () => ActionPlanSchema,
   AdapterLogDataSchema: () => AdapterLogDataSchema,
@@ -930,6 +938,10 @@ __export(index_exports, {
   AssertionEvaluator: () => AssertionEvaluator,
   AssertionResultSchema: () => AssertionResultSchema,
   AuthPluginDeclarationSchema: () => AuthPluginDeclarationSchema,
+  AuthStateConfigSchema: () => AuthStateConfigSchema,
+  AuthStateMetadataSchema: () => AuthStateMetadataSchema,
+  AuthStateNameSchema: () => AuthStateNameSchema,
+  AuthStateUseSchema: () => AuthStateUseSchema,
   BaseObservationSchema: () => BaseObservationSchema,
   BrowserConfigSchema: () => BrowserConfigSchema,
   CACHE_SCHEMA_VERSION: () => CACHE_SCHEMA_VERSION,
@@ -940,6 +952,7 @@ __export(index_exports, {
   ConsoleReporter: () => ConsoleReporter,
   CuratorResponseSchema: () => CuratorResponseSchema,
   DEFAULT_AGENT_QA_ARTIFACTS_DIR: () => DEFAULT_AGENT_QA_ARTIFACTS_DIR,
+  DEFAULT_AGENT_QA_AUTH_STATES_DIR: () => DEFAULT_AGENT_QA_AUTH_STATES_DIR,
   DEFAULT_AGENT_QA_CACHE_DIR: () => DEFAULT_AGENT_QA_CACHE_DIR,
   DEFAULT_AGENT_QA_RUNS_DB_PATH: () => DEFAULT_AGENT_QA_RUNS_DB_PATH,
   DEFAULT_AGENT_QA_RUNTIME_DIR: () => DEFAULT_AGENT_QA_RUNTIME_DIR,
@@ -1010,6 +1023,7 @@ __export(index_exports, {
   SuiteDefinitionSchema: () => SuiteDefinitionSchema,
   SuiteObservationSchema: () => SuiteObservationSchema,
   SuiteTestEntrySchema: () => SuiteTestEntrySchema,
+  TargetNameSchema: () => TargetNameSchema,
   TargetSchema: () => TargetSchema,
   TestDefinitionSchema: () => TestDefinitionSchema,
   TestMetaSchema: () => TestMetaSchema,
@@ -1028,6 +1042,7 @@ __export(index_exports, {
   browserstackProvider: () => browserstackProvider,
   buildAnalyticsEvent: () => buildAnalyticsEvent,
   buildAssertionPrompt: () => buildAssertionPrompt,
+  buildAuthStateHookEnv: () => buildAuthStateHookEnv,
   buildExtractionPrompt: () => buildExtractionPrompt,
   buildInternalRunAttributes: () => buildInternalRunAttributes,
   buildMemoryIndex: () => buildMemoryIndex,
@@ -1098,7 +1113,9 @@ __export(index_exports, {
   isBetterSqlite3NodeGypSymlinkConflict: () => isBetterSqlite3NodeGypSymlinkConflict,
   isMacPlatform: () => isMacPlatform,
   isPathInsideDir: () => isPathInsideDir,
+  isReservedAuthStateHookEnvKey: () => isReservedAuthStateHookEnvKey,
   isWorkspacePathMatch: () => isWorkspacePathMatch,
+  listAuthStateMetadata: () => listAuthStateMetadata,
   listLLMAuthProviderPlugins: () => listLLMAuthProviderPlugins,
   listObservations: () => listObservations,
   listProviders: () => listProviders,
@@ -1107,6 +1124,7 @@ __export(index_exports, {
   mapMobileCapabilities: () => mapMobileCapabilities,
   mapWebCapabilities: () => mapWebCapabilities,
   mergeRunAttributes: () => mergeRunAttributes,
+  normalizeAuthStateUse: () => normalizeAuthStateUse,
   normalizeRole: () => normalizeRole,
   parseAllTests: () => parseAllTests,
   parseEnvFile: () => parseEnvFile,
@@ -1120,17 +1138,25 @@ __export(index_exports, {
   parseTestFile: () => parseTestFile,
   readAnalyticsIdentity: () => readAnalyticsIdentity,
   readAuth: () => readAuth,
+  readAuthStateMetadata: () => readAuthStateMetadata,
+  redactAuthStateString: () => redactAuthStateString,
+  redactAuthStateValue: () => redactAuthStateValue,
   redactSecretValue: () => redactSecretValue,
   registerAllProviders: () => registerAllProviders,
   registerLLMAuthProviderPlugin: () => registerLLMAuthProviderPlugin,
   registerLLMAuthProviderPlugins: () => registerLLMAuthProviderPlugins,
   registerProvider: () => registerProvider,
   removeAuth: () => removeAuth,
+  removeAuthStateFiles: () => removeAuthStateFiles,
+  removeAuthStateTarget: () => removeAuthStateTarget,
   resetAnalyticsServiceForTests: () => resetAnalyticsServiceForTests,
   resolveAnalyticsAgentProduct: () => resolveAnalyticsAgentProduct,
   resolveAnalyticsIdentity: () => resolveAnalyticsIdentity,
   resolveAnalyticsStandardProperties: () => resolveAnalyticsStandardProperties,
   resolveAppiumExecutable: () => resolveAppiumExecutable,
+  resolveAuthStateForRun: () => resolveAuthStateForRun,
+  resolveAuthStatePaths: () => resolveAuthStatePaths,
+  resolveAuthStateRoot: () => resolveAuthStateRoot,
   resolveBetterSqliteRebuildCommand: () => resolveBetterSqliteRebuildCommand,
   resolveFarmCredentials: () => resolveFarmCredentials,
   resolveFileReferences: () => resolveFileReferences,
@@ -1151,6 +1177,7 @@ __export(index_exports, {
   shouldAblate: () => shouldAblate,
   sortRunAttributesForDisplay: () => sortRunAttributesForDisplay,
   stripHookInline: () => stripHookInline,
+  stripReservedAuthStateHookEnv: () => stripReservedAuthStateHookEnv,
   toolCallToActionPlan: () => toolCallToActionPlan,
   toolSchemaMiddleware: () => toolSchemaMiddleware,
   truncateScreenState: () => truncateScreenState,
@@ -1165,12 +1192,13 @@ __export(index_exports, {
   warnIfOutOfBounds: () => warnIfOutOfBounds,
   writeAnalyticsIdentity: () => writeAnalyticsIdentity,
   writeAuth: () => writeAuth,
+  writeAuthStateFiles: () => writeAuthStateFiles,
   writeObservation: () => writeObservation
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/schema/config-schema.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/schema/workspace-schema.ts
 var import_zod = require("zod");
@@ -1340,6 +1368,9 @@ var CacheConfigSchema = import_zod3.z.object({
   dir: import_zod3.z.string(),
   ttl: DurationString
 }).strict();
+var AuthStateConfigSchema = import_zod3.z.object({
+  dir: import_zod3.z.string().trim().min(1)
+}).strict();
 var LoggingConfigSchema = import_zod3.z.object({
   level: import_zod3.z.enum(["silent", "error", "warn", "info", "debug"])
 }).strict();
@@ -1374,6 +1405,7 @@ var ServicesSchema = import_zod3.z.object({
   dashboard: DashboardConfigSchema.optional(),
   mcp: McpConfigSchema.optional(),
   cache: CacheConfigSchema.optional(),
+  authState: AuthStateConfigSchema.optional(),
   logging: LoggingConfigSchema.optional(),
   recording: RecordingConfigSchema.optional(),
   accessibility: AccessibilityConfigSchema.optional(),
@@ -1381,34 +1413,56 @@ var ServicesSchema = import_zod3.z.object({
 }).strict();
 
 // src/schema/registry-schema.ts
+var import_zod5 = require("zod");
+
+// src/auth-state/schema.ts
 var import_zod4 = require("zod");
+var AUTH_STATE_SCHEMA_VERSION = 1;
+var AUTH_STATE_SLUG_PATTERN = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+var AuthStateNameSchema = import_zod4.z.string().regex(
+  AUTH_STATE_SLUG_PATTERN,
+  "Auth state name must match ^[a-z][a-z0-9-]*[a-z0-9]$"
+);
+var TargetNameSchema = import_zod4.z.string().regex(
+  AUTH_STATE_SLUG_PATTERN,
+  "Target name must match ^[a-z][a-z0-9-]*[a-z0-9]$"
+);
+var AuthStateMetadataSchema = import_zod4.z.object({
+  version: import_zod4.z.literal(AUTH_STATE_SCHEMA_VERSION),
+  kind: import_zod4.z.literal("web"),
+  target: TargetNameSchema,
+  name: AuthStateNameSchema,
+  capturedAt: import_zod4.z.string().datetime()
+}).strict();
+
+// src/schema/registry-schema.ts
 function isAbsoluteAppPath(value) {
   return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 }
-var AppInstallSchema = import_zod4.z.object({
-  path: import_zod4.z.string().refine((v) => !isAbsoluteAppPath(v), { message: "app.path must be relative" }).optional(),
-  browserstack: import_zod4.z.string().optional()
+var AppInstallSchema = import_zod5.z.object({
+  path: import_zod5.z.string().refine((v) => !isAbsoluteAppPath(v), { message: "app.path must be relative" }).optional(),
+  browserstack: import_zod5.z.string().optional()
 }).strict();
-var TargetSchema = import_zod4.z.object({
-  product: import_zod4.z.string().refine(
+var TargetSchema = import_zod5.z.object({
+  product: import_zod5.z.string().refine(
     (v) => !/\.\./.test(v) && !/[/\\]/.test(v) && !/\0/.test(v),
     { message: 'product must not contain "..", "/", "\\", or null bytes' }
   ).optional(),
-  platform: import_zod4.z.enum(["web", "android", "ios"]),
-  bundleId: import_zod4.z.string().optional(),
-  appPackage: import_zod4.z.string().optional(),
-  appActivity: import_zod4.z.string().optional(),
+  platform: import_zod5.z.enum(["web", "android", "ios"]),
+  bundleId: import_zod5.z.string().optional(),
+  appPackage: import_zod5.z.string().optional(),
+  appActivity: import_zod5.z.string().optional(),
   app: AppInstallSchema.optional(),
-  url: import_zod4.z.string().optional()
+  url: import_zod5.z.string().optional()
 }).strict().superRefine((val, ctx) => {
   if (val.platform === "web" && !val.url) {
-    ctx.addIssue({ code: import_zod4.z.ZodIssueCode.custom, message: "Web targets must have a url" });
+    ctx.addIssue({ code: import_zod5.z.ZodIssueCode.custom, message: "Web targets must have a url" });
   }
 });
-var DeviceProfileSchema = import_zod4.z.object({
-  platform: import_zod4.z.enum(["android", "ios"]),
+var DeviceProfileSchema = import_zod5.z.object({
+  platform: import_zod5.z.enum(["android", "ios"]),
   transport: TransportSchema,
-  match: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional().default({})
+  match: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional().default({})
 }).strict().superRefine((val, ctx) => {
   if (val.transport === "local") {
     const androidOnly = ["avd", "serial", "appPackage", "appActivity", "automationName", "browserName", "platformVersion"];
@@ -1417,7 +1471,7 @@ var DeviceProfileSchema = import_zod4.z.object({
     for (const key of Object.keys(val.match)) {
       if (!allowed.includes(key)) {
         ctx.addIssue({
-          code: import_zod4.z.ZodIssueCode.custom,
+          code: import_zod5.z.ZodIssueCode.custom,
           path: ["match", key],
           message: `Match field "${key}" is not valid for ${val.platform} local transport. Allowed: ${allowed.join(", ")}`
         });
@@ -1425,94 +1479,119 @@ var DeviceProfileSchema = import_zod4.z.object({
     }
   }
 });
-var ProviderConfigSchema = import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown());
-var RegistrySchema = import_zod4.z.object({
-  llms: import_zod4.z.array(NamedLLMConfigSchema).optional().default([]),
-  targets: import_zod4.z.record(import_zod4.z.string(), TargetSchema).optional(),
-  devices: import_zod4.z.record(import_zod4.z.string(), DeviceProfileSchema).optional(),
-  providers: import_zod4.z.record(import_zod4.z.string(), ProviderConfigSchema).optional()
+var ProviderConfigSchema = import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown());
+var RegistrySchema = import_zod5.z.object({
+  llms: import_zod5.z.array(NamedLLMConfigSchema).optional().default([]),
+  targets: import_zod5.z.record(TargetNameSchema, TargetSchema).optional(),
+  devices: import_zod5.z.record(import_zod5.z.string(), DeviceProfileSchema).optional(),
+  providers: import_zod5.z.record(import_zod5.z.string(), ProviderConfigSchema).optional()
 }).strict();
 
 // src/schema/use-schema.ts
-var import_zod5 = require("zod");
-var MobileAppStateSchema = import_zod5.z.enum(["preserve", "reset"]);
-var MobileUseSchema = import_zod5.z.object({
+var import_zod6 = require("zod");
+var MobileAppStateSchema = import_zod6.z.enum(["preserve", "reset"]);
+var MobileUseSchema = import_zod6.z.object({
   appState: MobileAppStateSchema
 }).strict();
-var MobileUseOverrideSchema = import_zod5.z.object({
+var MobileUseOverrideSchema = import_zod6.z.object({
   appState: MobileAppStateSchema.optional()
 }).strict();
-var UseSchema = import_zod5.z.object({
+var AuthStateUseSchema = import_zod6.z.union([
+  AuthStateNameSchema,
+  import_zod6.z.object({
+    name: AuthStateNameSchema,
+    load: import_zod6.z.boolean().optional(),
+    capture: import_zod6.z.boolean().optional()
+  }).strict()
+]);
+function normalizeAuthStateUse(use) {
+  const parsed = AuthStateUseSchema.safeParse(use?.authState);
+  if (!parsed.success) return void 0;
+  if (typeof parsed.data === "string") {
+    return {
+      name: parsed.data,
+      load: true,
+      capture: false
+    };
+  }
+  return {
+    name: parsed.data.name,
+    load: parsed.data.load ?? true,
+    capture: parsed.data.capture ?? false
+  };
+}
+var UseSchema = import_zod6.z.object({
   browser: BrowserConfigSchema.optional(),
   mobile: MobileUseSchema.optional(),
   timeout: TimeoutConfigSchema.optional(),
   healing: HealingConfigSchema.optional(),
   planner: PlannerConfigSchema.optional(),
   logCapture: LogCaptureConfigSchema.optional(),
-  cache: import_zod5.z.boolean().optional(),
-  llm: import_zod5.z.string().optional(),
-  parallel: import_zod5.z.boolean().optional()
+  cache: import_zod6.z.boolean().optional(),
+  llm: import_zod6.z.string().optional(),
+  parallel: import_zod6.z.boolean().optional()
 }).strict();
-var UseOverrideSchema = import_zod5.z.object({
-  browser: import_zod5.z.object({
-    name: import_zod5.z.enum(["chromium", "firefox", "webkit"]).optional(),
-    headless: import_zod5.z.boolean().optional(),
-    viewport: import_zod5.z.object({
-      width: import_zod5.z.number().optional(),
-      height: import_zod5.z.number().optional()
+var UseOverrideSchema = import_zod6.z.object({
+  browser: import_zod6.z.object({
+    name: import_zod6.z.enum(["chromium", "firefox", "webkit"]).optional(),
+    headless: import_zod6.z.boolean().optional(),
+    viewport: import_zod6.z.object({
+      width: import_zod6.z.number().optional(),
+      height: import_zod6.z.number().optional()
     }).strict().optional()
   }).strict().optional(),
-  timeout: import_zod5.z.object({
+  timeout: import_zod6.z.object({
     step: DurationString.optional(),
     test: DurationString.optional(),
     navigation: DurationString.optional()
   }).strict().optional(),
-  healing: import_zod5.z.object({
-    maxAttempts: import_zod5.z.number().optional()
+  healing: import_zod6.z.object({
+    maxAttempts: import_zod6.z.number().optional()
   }).strict().optional(),
-  planner: import_zod5.z.object({
-    maxSubActions: import_zod5.z.number().optional(),
-    previousStepCount: import_zod5.z.number().optional()
+  planner: import_zod6.z.object({
+    maxSubActions: import_zod6.z.number().optional(),
+    previousStepCount: import_zod6.z.number().optional()
   }).strict().optional(),
-  logCapture: import_zod5.z.object({
-    console: import_zod5.z.boolean().optional(),
-    network: import_zod5.z.boolean().optional()
+  logCapture: import_zod6.z.object({
+    console: import_zod6.z.boolean().optional(),
+    network: import_zod6.z.boolean().optional()
   }).strict().optional(),
-  cache: import_zod5.z.boolean().optional(),
+  cache: import_zod6.z.boolean().optional(),
+  authState: AuthStateUseSchema.optional(),
   mobile: MobileUseOverrideSchema.optional(),
-  llm: import_zod5.z.string().optional(),
-  parallel: import_zod5.z.boolean().optional(),
-  device: import_zod5.z.string().optional()
+  llm: import_zod6.z.string().optional(),
+  parallel: import_zod6.z.boolean().optional(),
+  device: import_zod6.z.string().optional()
 }).strict();
 
 // src/schema/analytics-schema.ts
-var import_zod6 = require("zod");
-var AttributePredicateSchema = import_zod6.z.union([
-  import_zod6.z.string(),
-  import_zod6.z.object({
-    regex: import_zod6.z.string().min(1)
+var import_zod7 = require("zod");
+var AttributePredicateSchema = import_zod7.z.union([
+  import_zod7.z.string(),
+  import_zod7.z.object({
+    regex: import_zod7.z.string().min(1)
   }).strict()
 ]);
-var AnalyticsSchema = import_zod6.z.object({
-  privacy: import_zod6.z.literal(true).optional(),
-  passRateScope: import_zod6.z.object({
-    attributes: import_zod6.z.record(import_zod6.z.string(), AttributePredicateSchema).optional()
+var AnalyticsSchema = import_zod7.z.object({
+  privacy: import_zod7.z.literal(true).optional(),
+  passRateScope: import_zod7.z.object({
+    attributes: import_zod7.z.record(import_zod7.z.string(), AttributePredicateSchema).optional()
   }).strict().optional()
 }).strict();
 
 // src/schema/config-schema.ts
-var AuthPluginDeclarationSchema = import_zod7.z.union([
-  import_zod7.z.object({
-    package: import_zod7.z.string().trim().min(1)
+var AuthPluginDeclarationSchema = import_zod8.z.union([
+  import_zod8.z.object({
+    package: import_zod8.z.string().trim().min(1)
   }).strict(),
-  import_zod7.z.object({
-    path: import_zod7.z.string().trim().min(1)
+  import_zod8.z.object({
+    path: import_zod8.z.string().trim().min(1)
   }).strict()
 ]);
-var PluginsSchema = import_zod7.z.object({
-  auth: import_zod7.z.array(AuthPluginDeclarationSchema).optional().default([])
+var PluginsSchema = import_zod8.z.object({
+  auth: import_zod8.z.array(AuthPluginDeclarationSchema).optional().default([])
 }).strict();
-var AgentQaConfigSchema = import_zod7.z.object({
+var AgentQaConfigSchema = import_zod8.z.object({
   workspace: WorkspaceSchema,
   services: ServicesSchema.optional(),
   registry: RegistrySchema.optional(),
@@ -1525,28 +1604,28 @@ var AgentQaConfigSchema = import_zod7.z.object({
   const dupes = names.filter((n, i) => names.indexOf(n) !== i);
   for (const dupe of new Set(dupes)) {
     ctx.addIssue({
-      code: import_zod7.z.ZodIssueCode.custom,
+      code: import_zod8.z.ZodIssueCode.custom,
       path: ["registry", "llms"],
       message: `Duplicate LLM config name: "${dupe}"`
     });
   }
   if (val.use?.platform) {
     ctx.addIssue({
-      code: import_zod7.z.ZodIssueCode.custom,
+      code: import_zod8.z.ZodIssueCode.custom,
       path: ["use", "platform"],
       message: "use.platform cannot be set at global config level. Set platform in test or suite YAML instead."
     });
   }
   if (val.use?.llm && !names.includes(val.use.llm)) {
     ctx.addIssue({
-      code: import_zod7.z.ZodIssueCode.custom,
+      code: import_zod8.z.ZodIssueCode.custom,
       path: ["use", "llm"],
       message: `use.llm "${val.use.llm}" does not match any name in registry.llms`
     });
   }
   if (!MobileAppStateSchema.safeParse(val.use?.mobile?.appState).success) {
     ctx.addIssue({
-      code: import_zod7.z.ZodIssueCode.custom,
+      code: import_zod8.z.ZodIssueCode.custom,
       path: ["use", "mobile", "appState"],
       message: "use.mobile.appState is required and must be one of: preserve | reset"
     });
@@ -1554,123 +1633,123 @@ var AgentQaConfigSchema = import_zod7.z.object({
 });
 
 // src/schema/test-schema.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_ms2 = __toESM(require("ms"), 1);
 var import_agent_qa_ids = require("@vostride/agent-qa-ids");
-var OptionalDuration = import_zod8.z.string().refine((v) => (0, import_ms2.default)(v) !== void 0, {
+var OptionalDuration = import_zod9.z.string().refine((v) => (0, import_ms2.default)(v) !== void 0, {
   message: 'Invalid duration format (e.g., "30s", "5m", "1h")'
 }).transform((v) => (0, import_ms2.default)(v)).optional();
-var CaptureConfigSchema = import_zod8.z.object({
-  variable: import_zod8.z.string(),
-  method: import_zod8.z.enum(["regex", "selector", "ai"]),
-  pattern: import_zod8.z.string().optional(),
-  selector: import_zod8.z.string().optional(),
-  description: import_zod8.z.string().optional()
+var CaptureConfigSchema = import_zod9.z.object({
+  variable: import_zod9.z.string(),
+  method: import_zod9.z.enum(["regex", "selector", "ai"]),
+  pattern: import_zod9.z.string().optional(),
+  selector: import_zod9.z.string().optional(),
+  description: import_zod9.z.string().optional()
 }).strict();
-var TestStepSchema = import_zod8.z.union([
-  import_zod8.z.string(),
-  import_zod8.z.object({
-    step: import_zod8.z.string(),
+var TestStepSchema = import_zod9.z.union([
+  import_zod9.z.string(),
+  import_zod9.z.object({
+    step: import_zod9.z.string(),
     timeout: OptionalDuration,
-    retries: import_zod8.z.number().optional(),
-    screenshot: import_zod8.z.boolean().optional(),
+    retries: import_zod9.z.number().optional(),
+    screenshot: import_zod9.z.boolean().optional(),
     capture: CaptureConfigSchema.optional(),
-    maxAttempts: import_zod8.z.number().optional()
+    maxAttempts: import_zod9.z.number().optional()
   }).strict()
 ]);
-var TestMetaSchema = import_zod8.z.object({
+var TestMetaSchema = import_zod9.z.object({
   timeout: OptionalDuration,
-  retries: import_zod8.z.number().optional(),
-  record: import_zod8.z.boolean().optional()
+  retries: import_zod9.z.number().optional(),
+  record: import_zod9.z.boolean().optional()
 }).strict();
-var HookIdSchema = import_zod8.z.string().refine((value) => (0, import_agent_qa_ids.isCanonicalHookId)(value), {
+var HookIdSchema = import_zod9.z.string().refine((value) => (0, import_agent_qa_ids.isCanonicalHookId)(value), {
   message: "Hook ID must be h_ followed by 10 id-agent words"
 });
-var TestDefinitionSchema = import_zod8.z.object({
-  "test-id": import_zod8.z.string().refine((value) => (0, import_agent_qa_ids.isCanonicalTestId)(value), {
+var TestDefinitionSchema = import_zod9.z.object({
+  "test-id": import_zod9.z.string().refine((value) => (0, import_agent_qa_ids.isCanonicalTestId)(value), {
     message: "Test ID must be t_ followed by 10 id-agent words"
   }),
-  name: import_zod8.z.string(),
-  target: import_zod8.z.string(),
-  context: import_zod8.z.string().optional(),
+  name: import_zod9.z.string(),
+  target: import_zod9.z.string(),
+  context: import_zod9.z.string().optional(),
   use: UseOverrideSchema.optional(),
   meta: TestMetaSchema.optional(),
-  setup: import_zod8.z.array(HookIdSchema).optional(),
-  teardown: import_zod8.z.array(HookIdSchema).optional(),
-  steps: import_zod8.z.array(TestStepSchema).min(1)
+  setup: import_zod9.z.array(HookIdSchema).optional(),
+  teardown: import_zod9.z.array(HookIdSchema).optional(),
+  steps: import_zod9.z.array(TestStepSchema).min(1)
 }).strict();
 
 // src/schema/action-schema.ts
-var import_zod9 = require("zod");
-var ActionPlanSchema = import_zod9.z.object({
-  reasoning: import_zod9.z.string().describe("Brief explanation of why this action was chosen"),
-  action: import_zod9.z.object({ type: import_zod9.z.string() }).passthrough(),
-  confidence: import_zod9.z.number().describe("Confidence level from 0 to 1"),
-  stepComplete: import_zod9.z.boolean().default(false).describe("Whether this action completes the step goal. Set true when the step objective is fully accomplished, false when more actions are needed."),
-  stepFailed: import_zod9.z.boolean().optional().default(false).describe("Set true when the step goal cannot be achieved from the current screen state. When true, no action is executed and the step fails with the reasoning as the error message.")
+var import_zod10 = require("zod");
+var ActionPlanSchema = import_zod10.z.object({
+  reasoning: import_zod10.z.string().describe("Brief explanation of why this action was chosen"),
+  action: import_zod10.z.object({ type: import_zod10.z.string() }).passthrough(),
+  confidence: import_zod10.z.number().describe("Confidence level from 0 to 1"),
+  stepComplete: import_zod10.z.boolean().default(false).describe("Whether this action completes the step goal. Set true when the step objective is fully accomplished, false when more actions are needed."),
+  stepFailed: import_zod10.z.boolean().optional().default(false).describe("Set true when the step goal cannot be achieved from the current screen state. When true, no action is executed and the step fails with the reasoning as the error message.")
 });
 
 // src/schema/suite-schema.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var import_agent_qa_ids2 = require("@vostride/agent-qa-ids");
-var SuiteTestEntrySchema = import_zod10.z.object({
-  test: import_zod10.z.string(),
-  id: import_zod10.z.string().refine((value) => (0, import_agent_qa_ids2.isCanonicalTestId)(value), {
+var SuiteTestEntrySchema = import_zod11.z.object({
+  test: import_zod11.z.string(),
+  id: import_zod11.z.string().refine((value) => (0, import_agent_qa_ids2.isCanonicalTestId)(value), {
     message: "Test ID must be t_ followed by 10 id-agent words"
   })
 }).strict();
-var HookIdSchema2 = import_zod10.z.string().refine((value) => (0, import_agent_qa_ids2.isCanonicalHookId)(value), {
+var HookIdSchema2 = import_zod11.z.string().refine((value) => (0, import_agent_qa_ids2.isCanonicalHookId)(value), {
   message: "Hook ID must be h_ followed by 10 id-agent words"
 });
-var SuiteDefinitionSchema = import_zod10.z.object({
-  "suite-id": import_zod10.z.string().refine((value) => (0, import_agent_qa_ids2.isCanonicalSuiteId)(value), {
+var SuiteDefinitionSchema = import_zod11.z.object({
+  "suite-id": import_zod11.z.string().refine((value) => (0, import_agent_qa_ids2.isCanonicalSuiteId)(value), {
     message: "Suite ID must be s_ followed by 10 id-agent words"
   }).optional(),
-  name: import_zod10.z.string(),
-  target: import_zod10.z.string(),
-  context: import_zod10.z.string().optional(),
-  setup: import_zod10.z.array(HookIdSchema2).optional(),
-  teardown: import_zod10.z.array(HookIdSchema2).optional(),
-  tests: import_zod10.z.array(SuiteTestEntrySchema).min(1),
+  name: import_zod11.z.string(),
+  target: import_zod11.z.string(),
+  context: import_zod11.z.string().optional(),
+  setup: import_zod11.z.array(HookIdSchema2).optional(),
+  teardown: import_zod11.z.array(HookIdSchema2).optional(),
+  tests: import_zod11.z.array(SuiteTestEntrySchema).min(1),
   use: UseOverrideSchema.optional()
 }).strict();
 
 // src/hooks/schema.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var import_ms3 = __toESM(require("ms"), 1);
 var import_agent_qa_ids3 = require("@vostride/agent-qa-ids");
-var HookDurationString = import_zod11.z.string().refine((v) => (0, import_ms3.default)(v) !== void 0, {
+var HookDurationString = import_zod12.z.string().refine((v) => (0, import_ms3.default)(v) !== void 0, {
   message: 'Invalid duration format (e.g., "30s", "2m", "1h")'
 }).transform((v) => (0, import_ms3.default)(v));
 var HOOK_ID_MESSAGE = "Hook ID must be h_ followed by 10 id-agent words";
-var HookDefinitionSchema = import_zod11.z.object({
-  id: import_zod11.z.string().refine((value) => (0, import_agent_qa_ids3.isCanonicalHookId)(value), {
+var HookDefinitionSchema = import_zod12.z.object({
+  id: import_zod12.z.string().refine((value) => (0, import_agent_qa_ids3.isCanonicalHookId)(value), {
     message: HOOK_ID_MESSAGE
   }),
-  name: import_zod11.z.string().min(1),
-  runtime: import_zod11.z.enum(["node", "bun", "python", "bash"]),
-  file: import_zod11.z.string().min(1),
-  deps: import_zod11.z.array(import_zod11.z.string()).optional().default([]),
-  packageFile: import_zod11.z.string().optional(),
+  name: import_zod12.z.string().min(1),
+  runtime: import_zod12.z.enum(["node", "bun", "python", "bash"]),
+  file: import_zod12.z.string().min(1),
+  deps: import_zod12.z.array(import_zod12.z.string()).optional().default([]),
+  packageFile: import_zod12.z.string().optional(),
   timeout: HookDurationString,
-  network: import_zod11.z.boolean().optional().default(true)
+  network: import_zod12.z.boolean().optional().default(true)
 });
-var HooksFileSchema = import_zod11.z.object({
-  hooks: import_zod11.z.array(HookDefinitionSchema)
+var HooksFileSchema = import_zod12.z.object({
+  hooks: import_zod12.z.array(HookDefinitionSchema)
 }).superRefine((val, ctx) => {
   const ids = /* @__PURE__ */ new Set();
   const names = /* @__PURE__ */ new Set();
   for (let i = 0; i < val.hooks.length; i++) {
     if (ids.has(val.hooks[i].id)) {
       ctx.addIssue({
-        code: import_zod11.z.ZodIssueCode.custom,
+        code: import_zod12.z.ZodIssueCode.custom,
         path: ["hooks", i, "id"],
         message: `Duplicate hook id: "${val.hooks[i].id}"`
       });
     }
     if (names.has(val.hooks[i].name)) {
       ctx.addIssue({
-        code: import_zod11.z.ZodIssueCode.custom,
+        code: import_zod12.z.ZodIssueCode.custom,
         path: ["hooks", i, "name"],
         message: `Duplicate hook name: "${val.hooks[i].name}"`
       });
@@ -1736,8 +1815,8 @@ function formatYamlError(err, linePos, content, filePath) {
     suggestion: void 0
   };
 }
-function zodPathToSuggestion(code, path5, message) {
-  const field = path5[path5.length - 1];
+function zodPathToSuggestion(code, path7, message) {
+  const field = path7[path7.length - 1];
   if (code === "invalid_type") {
     if (typeof field === "string") {
       return `check that '${field}' has the correct type`;
@@ -1761,10 +1840,10 @@ function zodPathToSuggestion(code, path5, message) {
   }
   return void 0;
 }
-function resolveNodeAtPath(doc, path5) {
+function resolveNodeAtPath(doc, path7) {
   let current = doc.contents;
   if (!current) return null;
-  for (const segment of path5) {
+  for (const segment of path7) {
     if (!current) return null;
     if (typeof segment === "number") {
       const items = current.items;
@@ -1827,7 +1906,7 @@ function formatZodErrors(zodError, doc, lineCounter, content, filePath) {
 
 // src/agent/variables.ts
 var import_ai2 = require("ai");
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/agent/observation.ts
 var import_node_crypto = require("crypto");
@@ -1964,12 +2043,12 @@ function getPlatformFilter(name) {
 
 // src/tools/builder.ts
 var import_ai = require("ai");
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var PLAN_FIELDS = {
-  reasoning: import_zod12.z.string().describe("Brief explanation of why this action was chosen"),
-  confidence: import_zod12.z.number().describe("Confidence level from 0 to 1"),
-  stepComplete: import_zod12.z.boolean().describe("Whether this action completes the step goal"),
-  stepFailed: import_zod12.z.boolean().optional().describe("Set true when the step goal cannot be achieved")
+  reasoning: import_zod13.z.string().describe("Brief explanation of why this action was chosen"),
+  confidence: import_zod13.z.number().describe("Confidence level from 0 to 1"),
+  stepComplete: import_zod13.z.boolean().describe("Whether this action completes the step goal"),
+  stepFailed: import_zod13.z.boolean().optional().describe("Set true when the step goal cannot be achieved")
 };
 var ToolValidationError = class extends Error {
   toolName;
@@ -1987,7 +2066,7 @@ function buildTools(registry, options) {
     const actionShape = def.schema.shape;
     tools[def.name] = (0, import_ai.tool)({
       description: def.description,
-      inputSchema: import_zod12.z.object({ ...PLAN_FIELDS, ...actionShape })
+      inputSchema: import_zod13.z.object({ ...PLAN_FIELDS, ...actionShape })
     });
   }
   return tools;
@@ -2009,7 +2088,7 @@ function toolCallToActionPlan(toolName, args, registry) {
 }
 
 // src/tools/actions/index.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 function action(name, description, schema) {
   return {
     name,
@@ -2020,204 +2099,204 @@ function action(name, description, schema) {
   };
 }
 var ACTION_DEFINITIONS = [
-  action("click", "Click an element", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference from the screen state"),
-    clickDelay: import_zod13.z.number().optional().describe("Omit when there is no requested delay. Only provide a positive value when the user explicitly asks for a delay.")
+  action("click", "Click an element", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference from the screen state"),
+    clickDelay: import_zod14.z.number().optional().describe("Omit when there is no requested delay. Only provide a positive value when the user explicitly asks for a delay.")
   })),
-  action("fill", "Fill text into an input field", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference for the input field"),
-    value: import_zod13.z.string().describe("Text value to fill into the input")
+  action("fill", "Fill text into an input field", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference for the input field"),
+    value: import_zod14.z.string().describe("Text value to fill into the input")
   })),
-  action("select", "Select an option from a dropdown", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference for the select/dropdown"),
-    value: import_zod13.z.string().describe("Option value to select")
+  action("select", "Select an option from a dropdown", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference for the select/dropdown"),
+    value: import_zod14.z.string().describe("Option value to select")
   })),
-  action("nativeSelect", "Select a value from a native mobile picker, picker wheel, spinner, or dropdown/list control", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference for the native picker/dropdown control"),
-    value: import_zod13.z.string().describe("Visible text/value to select")
+  action("nativeSelect", "Select a value from a native mobile picker, picker wheel, spinner, or dropdown/list control", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference for the native picker/dropdown control"),
+    value: import_zod14.z.string().describe("Visible text/value to select")
   })),
-  action("navigate", "Navigate to a URL", import_zod13.z.object({
-    url: import_zod13.z.string().describe("URL to navigate to")
+  action("navigate", "Navigate to a URL", import_zod14.z.object({
+    url: import_zod14.z.string().describe("URL to navigate to")
   })),
-  action("scroll", "Scroll the page or a specific element", import_zod13.z.object({
-    scrollType: import_zod13.z.enum(["vertical", "horizontal"]).describe("Scroll axis: vertical (up/down) or horizontal (left/right)"),
-    value: import_zod13.z.number().describe("Scroll distance in pixels. Positive = down/right, negative = up/left"),
-    ref: import_zod13.z.string().optional().describe("Optional element to scroll within"),
-    duration: import_zod13.z.number().optional().describe("Scroll duration in ms (mobile only \u2014 web ignores this)")
+  action("scroll", "Scroll the page or a specific element", import_zod14.z.object({
+    scrollType: import_zod14.z.enum(["vertical", "horizontal"]).describe("Scroll axis: vertical (up/down) or horizontal (left/right)"),
+    value: import_zod14.z.number().describe("Scroll distance in pixels. Positive = down/right, negative = up/left"),
+    ref: import_zod14.z.string().optional().describe("Optional element to scroll within"),
+    duration: import_zod14.z.number().optional().describe("Scroll duration in ms (mobile only \u2014 web ignores this)")
   })),
-  action("delay", 'Pause execution for a fixed duration \u2014 use when a specific duration is requested (e.g. "wait 3 seconds"). Do NOT use for waiting on conditions (use waitFor for that).', import_zod13.z.object({
-    ms: import_zod13.z.number().describe("Duration in milliseconds")
+  action("delay", 'Pause execution for a fixed duration \u2014 use when a specific duration is requested (e.g. "wait 3 seconds"). Do NOT use for waiting on conditions (use waitFor for that).', import_zod14.z.object({
+    ms: import_zod14.z.number().describe("Duration in milliseconds")
   })),
-  action("waitFor", "Wait for a condition to be met (text content match or selector)", import_zod13.z.object({
-    condition: import_zod13.z.string().describe("Condition to wait for \u2014 either visible text content or a CSS selector"),
-    timeout: import_zod13.z.number().optional().describe("Maximum wait time in ms (default: 5000)")
+  action("waitFor", "Wait for a condition to be met (text content match or selector)", import_zod14.z.object({
+    condition: import_zod14.z.string().describe("Condition to wait for \u2014 either visible text content or a CSS selector"),
+    timeout: import_zod14.z.number().optional().describe("Maximum wait time in ms (default: 5000)")
   })),
-  action("assert", "Assert a condition on the current page state", import_zod13.z.object({
-    condition: import_zod13.z.string().describe("Assertion condition to check"),
-    expected: import_zod13.z.string().optional().describe("Expected value for comparison"),
-    visual: import_zod13.z.boolean().optional().default(true).describe("Whether this assertion requires screen evidence. Set false for non-visual checks (tautologies, hook/env results, runJS outputs, computed values). Default true for screen-visible assertions.")
+  action("assert", "Assert a condition on the current page state", import_zod14.z.object({
+    condition: import_zod14.z.string().describe("Assertion condition to check"),
+    expected: import_zod14.z.string().optional().describe("Expected value for comparison"),
+    visual: import_zod14.z.boolean().optional().default(true).describe("Whether this assertion requires screen evidence. Set false for non-visual checks (tautologies, hook/env results, runJS outputs, computed values). Default true for screen-visible assertions.")
   })),
-  action("keypress", "Press one or more keyboard keys/combos in sequence", import_zod13.z.object({
-    keys: import_zod13.z.array(import_zod13.z.string()).min(1).describe('Array of keys/combos to press in sequence. Each entry may be a single key (e.g. "Enter", "Tab", "Escape") or a combo with "+" separators (e.g. "Meta+k", "Control+Shift+T"). Use "Meta" for the Cmd/Win/Super key \u2014 on non-Mac platforms it is automatically converted to "Control" when convertPlatformKeys is true. On mobile, only single special keys from the KEY_MAP work meaningfully; combos are a no-op.'),
-    convertPlatformKeys: import_zod13.z.boolean().optional().default(true).describe('When true (default), replaces "Meta" with "Control" in each key string on non-Mac platforms so that "Meta+k" works as Cmd+K on Mac and Ctrl+K on Windows/Linux. Set to false to pass keys through unchanged. No-op on mobile.')
+  action("keypress", "Press one or more keyboard keys/combos in sequence", import_zod14.z.object({
+    keys: import_zod14.z.array(import_zod14.z.string()).min(1).describe('Array of keys/combos to press in sequence. Each entry may be a single key (e.g. "Enter", "Tab", "Escape") or a combo with "+" separators (e.g. "Meta+k", "Control+Shift+T"). Use "Meta" for the Cmd/Win/Super key \u2014 on non-Mac platforms it is automatically converted to "Control" when convertPlatformKeys is true. On mobile, only single special keys from the KEY_MAP work meaningfully; combos are a no-op.'),
+    convertPlatformKeys: import_zod14.z.boolean().optional().default(true).describe('When true (default), replaces "Meta" with "Control" in each key string on non-Mac platforms so that "Meta+k" works as Cmd+K on Mac and Ctrl+K on Windows/Linux. Set to false to pass keys through unchanged. No-op on mobile.')
   })),
-  action("hover", "Hover over an element", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference to hover over")
+  action("hover", "Hover over an element", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference to hover over")
   })),
-  action("paste", "Paste text into an element via clipboard paste event", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference for the target element"),
-    value: import_zod13.z.string().describe("Text value to paste")
+  action("paste", "Paste text into an element via clipboard paste event", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference for the target element"),
+    value: import_zod14.z.string().describe("Text value to paste")
   })),
-  action("keyDown", "Hold down a key (for modifier combos like Shift+Click)", import_zod13.z.object({
-    key: import_zod13.z.string().describe("Key to hold down (e.g., Shift, Control, Alt, Meta)")
+  action("keyDown", "Hold down a key (for modifier combos like Shift+Click)", import_zod14.z.object({
+    key: import_zod14.z.string().describe("Key to hold down (e.g., Shift, Control, Alt, Meta)")
   })),
-  action("keyUp", "Release a held key", import_zod13.z.object({
-    key: import_zod13.z.string().describe("Key to release (e.g., Shift, Control, Alt, Meta)")
+  action("keyUp", "Release a held key", import_zod14.z.object({
+    key: import_zod14.z.string().describe("Key to release (e.g., Shift, Control, Alt, Meta)")
   })),
-  action("refresh", "Refresh the current page", import_zod13.z.object({})),
-  action("navigateHistory", "Navigate browser history (back or forward)", import_zod13.z.object({
-    direction: import_zod13.z.enum(["back", "forward"]).describe("Navigation direction in browser history")
+  action("refresh", "Refresh the current page", import_zod14.z.object({})),
+  action("navigateHistory", "Navigate browser history (back or forward)", import_zod14.z.object({
+    direction: import_zod14.z.enum(["back", "forward"]).describe("Navigation direction in browser history")
   })),
-  action("readConsoleLogs", "Read console log entries from the browser", import_zod13.z.object({
-    level: import_zod13.z.enum(["log", "info", "warn", "error"]).optional().describe("Filter by log level. Omit to get all levels."),
-    tab: import_zod13.z.object({
-      index: import_zod13.z.number().optional().describe("0-based tab index"),
-      title: import_zod13.z.string().optional().describe("Substring match on page title"),
-      url: import_zod13.z.string().optional().describe("Substring match on page URL")
+  action("readConsoleLogs", "Read console log entries from the browser", import_zod14.z.object({
+    level: import_zod14.z.enum(["log", "info", "warn", "error"]).optional().describe("Filter by log level. Omit to get all levels."),
+    tab: import_zod14.z.object({
+      index: import_zod14.z.number().optional().describe("0-based tab index"),
+      title: import_zod14.z.string().optional().describe("Substring match on page title"),
+      url: import_zod14.z.string().optional().describe("Substring match on page URL")
     }).optional().describe("Target a specific tab. Omit to read logs from all tabs.")
   })),
-  action("readNetworkLogs", "Read network request/response log entries", import_zod13.z.object({
-    urlPattern: import_zod13.z.string().optional().describe("Filter by URL substring match. Omit to get all requests."),
-    tab: import_zod13.z.object({
-      index: import_zod13.z.number().optional().describe("0-based tab index"),
-      title: import_zod13.z.string().optional().describe("Substring match on page title"),
-      url: import_zod13.z.string().optional().describe("Substring match on page URL")
+  action("readNetworkLogs", "Read network request/response log entries", import_zod14.z.object({
+    urlPattern: import_zod14.z.string().optional().describe("Filter by URL substring match. Omit to get all requests."),
+    tab: import_zod14.z.object({
+      index: import_zod14.z.number().optional().describe("0-based tab index"),
+      title: import_zod14.z.string().optional().describe("Substring match on page title"),
+      url: import_zod14.z.string().optional().describe("Substring match on page URL")
     }).optional().describe("Target a specific tab. Omit to read logs from all tabs.")
   })),
-  action("readCookies", "Read browser cookies", import_zod13.z.object({
-    name: import_zod13.z.string().optional().describe("Cookie name to read. Omit to get all cookies.")
+  action("readCookies", "Read browser cookies", import_zod14.z.object({
+    name: import_zod14.z.string().optional().describe("Cookie name to read. Omit to get all cookies.")
   })),
-  action("setCookies", "Set browser cookies", import_zod13.z.object({
-    cookies: import_zod13.z.array(import_zod13.z.object({
-      name: import_zod13.z.string().describe("Cookie name"),
-      value: import_zod13.z.string().describe("Cookie value"),
-      domain: import_zod13.z.string().optional().describe("Cookie domain"),
-      path: import_zod13.z.string().optional().describe("Cookie path"),
-      httpOnly: import_zod13.z.boolean().optional().describe("HTTP only flag"),
-      secure: import_zod13.z.boolean().optional().describe("Secure flag"),
-      sameSite: import_zod13.z.enum(["Strict", "Lax", "None"]).optional().describe("SameSite attribute"),
-      expires: import_zod13.z.number().optional().describe("Expiry as Unix timestamp in seconds")
+  action("setCookies", "Set browser cookies", import_zod14.z.object({
+    cookies: import_zod14.z.array(import_zod14.z.object({
+      name: import_zod14.z.string().describe("Cookie name"),
+      value: import_zod14.z.string().describe("Cookie value"),
+      domain: import_zod14.z.string().optional().describe("Cookie domain"),
+      path: import_zod14.z.string().optional().describe("Cookie path"),
+      httpOnly: import_zod14.z.boolean().optional().describe("HTTP only flag"),
+      secure: import_zod14.z.boolean().optional().describe("Secure flag"),
+      sameSite: import_zod14.z.enum(["Strict", "Lax", "None"]).optional().describe("SameSite attribute"),
+      expires: import_zod14.z.number().optional().describe("Expiry as Unix timestamp in seconds")
     })).describe("Array of cookies to set")
   })),
-  action("readLocalStorage", "Read local storage entries", import_zod13.z.object({
-    key: import_zod13.z.string().optional().describe("Storage key to read. Omit to get all entries.")
+  action("readLocalStorage", "Read local storage entries", import_zod14.z.object({
+    key: import_zod14.z.string().optional().describe("Storage key to read. Omit to get all entries.")
   })),
-  action("setLocalStorage", "Set local storage entries", import_zod13.z.object({
-    entries: import_zod13.z.array(import_zod13.z.object({
-      key: import_zod13.z.string().describe("Storage key"),
-      value: import_zod13.z.string().describe("Storage value")
+  action("setLocalStorage", "Set local storage entries", import_zod14.z.object({
+    entries: import_zod14.z.array(import_zod14.z.object({
+      key: import_zod14.z.string().describe("Storage key"),
+      value: import_zod14.z.string().describe("Storage value")
     })).describe("Array of key-value pairs to set")
   })),
-  action("tap", "Tap an element on a mobile device", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference to tap")
+  action("tap", "Tap an element on a mobile device", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference to tap")
   })),
-  action("swipe", "Swipe gesture on a mobile device", import_zod13.z.object({
-    direction: import_zod13.z.enum(["up", "down", "left", "right"]).describe("Swipe direction"),
-    ref: import_zod13.z.string().optional().describe("Optional element to swipe within"),
-    startX: import_zod13.z.number().optional().describe("Start X coordinate (overrides direction-based calculation)"),
-    startY: import_zod13.z.number().optional().describe("Start Y coordinate (overrides direction-based calculation)"),
-    endX: import_zod13.z.number().optional().describe("End X coordinate (overrides direction-based calculation)"),
-    endY: import_zod13.z.number().optional().describe("End Y coordinate (overrides direction-based calculation)"),
-    duration: import_zod13.z.number().optional().describe("Swipe duration in ms (default: 300)")
+  action("swipe", "Swipe gesture on a mobile device", import_zod14.z.object({
+    direction: import_zod14.z.enum(["up", "down", "left", "right"]).describe("Swipe direction"),
+    ref: import_zod14.z.string().optional().describe("Optional element to swipe within"),
+    startX: import_zod14.z.number().optional().describe("Start X coordinate (overrides direction-based calculation)"),
+    startY: import_zod14.z.number().optional().describe("Start Y coordinate (overrides direction-based calculation)"),
+    endX: import_zod14.z.number().optional().describe("End X coordinate (overrides direction-based calculation)"),
+    endY: import_zod14.z.number().optional().describe("End Y coordinate (overrides direction-based calculation)"),
+    duration: import_zod14.z.number().optional().describe("Swipe duration in ms (default: 300)")
   })),
-  action("longpress", "Long-press an element on a mobile device", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference to long-press"),
-    duration: import_zod13.z.number().optional().describe("Long-press duration in ms")
+  action("longpress", "Long-press an element on a mobile device", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference to long-press"),
+    duration: import_zod14.z.number().optional().describe("Long-press duration in ms")
   })),
-  action("hideKeyboard", "Dismiss the on-screen keyboard (mobile only, no-op on web)", import_zod13.z.object({})),
-  action("clearText", "Clear all text from an input field without typing new text", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference for the input field to clear")
+  action("hideKeyboard", "Dismiss the on-screen keyboard (mobile only, no-op on web)", import_zod14.z.object({})),
+  action("clearText", "Clear all text from an input field without typing new text", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference for the input field to clear")
   })),
-  action("openLink", "Open a deep link in a mobile app \u2014 use navigate for web URLs", import_zod13.z.object({
-    url: import_zod13.z.string().describe("Deep link URL to open (e.g. myapp://screen, intent://...)"),
-    appId: import_zod13.z.string().optional().describe("Generic mobile app identifier. Android uses package name; iOS uses bundle ID."),
-    bundleId: import_zod13.z.string().optional().describe("iOS bundle ID to open the link in"),
-    appPackage: import_zod13.z.string().optional().describe("Android package name to open the link in"),
-    waitForLaunch: import_zod13.z.boolean().optional().describe("Whether to wait for the app to launch after opening the link")
+  action("openLink", "Open a deep link in a mobile app \u2014 use navigate for web URLs", import_zod14.z.object({
+    url: import_zod14.z.string().describe("Deep link URL to open (e.g. myapp://screen, intent://...)"),
+    appId: import_zod14.z.string().optional().describe("Generic mobile app identifier. Android uses package name; iOS uses bundle ID."),
+    bundleId: import_zod14.z.string().optional().describe("iOS bundle ID to open the link in"),
+    appPackage: import_zod14.z.string().optional().describe("Android package name to open the link in"),
+    waitForLaunch: import_zod14.z.boolean().optional().describe("Whether to wait for the app to launch after opening the link")
   })),
-  action("drag", "Drag an element to another element (reorder lists, sliders)", import_zod13.z.object({
-    fromRef: import_zod13.z.string().describe("Element reference to drag from"),
-    toRef: import_zod13.z.string().describe("Element reference to drag to")
+  action("drag", "Drag an element to another element (reorder lists, sliders)", import_zod14.z.object({
+    fromRef: import_zod14.z.string().describe("Element reference to drag from"),
+    toRef: import_zod14.z.string().describe("Element reference to drag to")
   })),
-  action("doubleTap", "Double-tap an element (text selection, zoom)", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference to double-tap")
+  action("doubleTap", "Double-tap an element (text selection, zoom)", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference to double-tap")
   })),
-  action("launchApp", "Launch or bring an app to the foreground", import_zod13.z.object({
-    bundleId: import_zod13.z.string().describe("App bundle ID (iOS) or package name (Android)")
+  action("launchApp", "Launch or bring an app to the foreground", import_zod14.z.object({
+    bundleId: import_zod14.z.string().describe("App bundle ID (iOS) or package name (Android)")
   })),
-  action("stopApp", "Terminate a running app", import_zod13.z.object({
-    bundleId: import_zod13.z.string().describe("App bundle ID (iOS) or package name (Android)")
+  action("stopApp", "Terminate a running app", import_zod14.z.object({
+    bundleId: import_zod14.z.string().describe("App bundle ID (iOS) or package name (Android)")
   })),
-  action("setOrientation", "Set the device orientation (mobile only)", import_zod13.z.object({
-    orientation: import_zod13.z.enum(["portrait", "landscape"]).describe("Device orientation")
+  action("setOrientation", "Set the device orientation (mobile only)", import_zod14.z.object({
+    orientation: import_zod14.z.enum(["portrait", "landscape"]).describe("Device orientation")
   })),
-  action("pinch", "Pinch zoom gesture on a mobile device (mobile only)", import_zod13.z.object({
-    scale: import_zod13.z.number().describe("Scale factor: >1 to zoom in (spread fingers), <1 to zoom out (pinch fingers)"),
-    x: import_zod13.z.number().optional().describe("Center X coordinate for pinch gesture"),
-    y: import_zod13.z.number().optional().describe("Center Y coordinate for pinch gesture"),
-    ref: import_zod13.z.string().optional().describe("Optional element to center the pinch on")
+  action("pinch", "Pinch zoom gesture on a mobile device (mobile only)", import_zod14.z.object({
+    scale: import_zod14.z.number().describe("Scale factor: >1 to zoom in (spread fingers), <1 to zoom out (pinch fingers)"),
+    x: import_zod14.z.number().optional().describe("Center X coordinate for pinch gesture"),
+    y: import_zod14.z.number().optional().describe("Center Y coordinate for pinch gesture"),
+    ref: import_zod14.z.string().optional().describe("Optional element to center the pinch on")
   })),
-  action("multiTap", "Multi-finger tap gesture on a mobile device (mobile only)", import_zod13.z.object({
-    fingers: import_zod13.z.number().describe("Number of fingers (2 or 3)"),
-    x: import_zod13.z.number().optional().describe("Center X coordinate for multi-finger tap"),
-    y: import_zod13.z.number().optional().describe("Center Y coordinate for multi-finger tap"),
-    ref: import_zod13.z.string().optional().describe("Optional element to center the tap on")
+  action("multiTap", "Multi-finger tap gesture on a mobile device (mobile only)", import_zod14.z.object({
+    fingers: import_zod14.z.number().describe("Number of fingers (2 or 3)"),
+    x: import_zod14.z.number().optional().describe("Center X coordinate for multi-finger tap"),
+    y: import_zod14.z.number().optional().describe("Center Y coordinate for multi-finger tap"),
+    ref: import_zod14.z.string().optional().describe("Optional element to center the tap on")
   })),
-  action("tapCoordinate", "Tap at specific pixel coordinates \u2014 use when target element has no ref in accessibility tree", import_zod13.z.object({
-    x: import_zod13.z.number().describe("X coordinate in pixels"),
-    y: import_zod13.z.number().describe("Y coordinate in pixels")
+  action("tapCoordinate", "Tap at specific pixel coordinates \u2014 use when target element has no ref in accessibility tree", import_zod14.z.object({
+    x: import_zod14.z.number().describe("X coordinate in pixels"),
+    y: import_zod14.z.number().describe("Y coordinate in pixels")
   })),
-  action("executeScript", "Execute an Appium script command (mobile only)", import_zod13.z.object({
-    command: import_zod13.z.string().describe('Appium command name (e.g., "mobile: enrollBiometric", "mobile: terminateApp")'),
-    args: import_zod13.z.any().optional().describe("Command arguments \u2014 object with key-value pairs, or array for some commands")
+  action("executeScript", "Execute an Appium script command (mobile only)", import_zod14.z.object({
+    command: import_zod14.z.string().describe('Appium command name (e.g., "mobile: enrollBiometric", "mobile: terminateApp")'),
+    args: import_zod14.z.any().optional().describe("Command arguments \u2014 object with key-value pairs, or array for some commands")
   })),
-  action("setVariable", "Set a runtime environment variable for use in subsequent steps", import_zod13.z.object({
-    name: import_zod13.z.string().describe("Variable name (will be accessible via {{env:varName}})"),
-    value: import_zod13.z.string().describe("Variable value to store")
+  action("setVariable", "Set a runtime environment variable for use in subsequent steps", import_zod14.z.object({
+    name: import_zod14.z.string().describe("Variable name (will be accessible via {{env:varName}})"),
+    value: import_zod14.z.string().describe("Variable value to store")
   })),
-  action("newTab", "Open a URL in a new browser tab and switch to it", import_zod13.z.object({
-    url: import_zod13.z.string().describe("URL to open in the new tab")
+  action("newTab", "Open a URL in a new browser tab and switch to it", import_zod14.z.object({
+    url: import_zod14.z.string().describe("URL to open in the new tab")
   })),
-  action("switchTab", "Switch to an open browser tab", import_zod13.z.object({
-    index: import_zod13.z.number().optional().describe("0-based tab index to switch to"),
-    title: import_zod13.z.string().optional().describe("Substring match on page title"),
-    url: import_zod13.z.string().optional().describe("Substring match on page URL")
+  action("switchTab", "Switch to an open browser tab", import_zod14.z.object({
+    index: import_zod14.z.number().optional().describe("0-based tab index to switch to"),
+    title: import_zod14.z.string().optional().describe("Substring match on page title"),
+    url: import_zod14.z.string().optional().describe("Substring match on page URL")
   })),
-  action("doubleClick", "Double-click an element (text selection, expand, web-only)", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference from the screen state"),
-    relativePosition: import_zod13.z.object({
-      x: import_zod13.z.number().describe("X offset in pixels from element top-left"),
-      y: import_zod13.z.number().describe("Y offset in pixels from element top-left")
+  action("doubleClick", "Double-click an element (text selection, expand, web-only)", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference from the screen state"),
+    relativePosition: import_zod14.z.object({
+      x: import_zod14.z.number().describe("X offset in pixels from element top-left"),
+      y: import_zod14.z.number().describe("Y offset in pixels from element top-left")
     }).optional().describe("Omit for normal element-center interaction. Only provide when the user explicitly asks for an offset. Do not use { x: 0, y: 0 } for a normal button double-click/right-click; top-left is often intercepted."),
-    clickDelay: import_zod13.z.number().optional().describe("Omit when there is no requested delay. Only provide a positive value when the user explicitly asks for a delay.")
+    clickDelay: import_zod14.z.number().optional().describe("Omit when there is no requested delay. Only provide a positive value when the user explicitly asks for a delay.")
   })),
-  action("rightClick", "Right-click an element to open context menu (web-only)", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference from the screen state"),
-    relativePosition: import_zod13.z.object({
-      x: import_zod13.z.number().describe("X offset in pixels from element top-left"),
-      y: import_zod13.z.number().describe("Y offset in pixels from element top-left")
+  action("rightClick", "Right-click an element to open context menu (web-only)", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference from the screen state"),
+    relativePosition: import_zod14.z.object({
+      x: import_zod14.z.number().describe("X offset in pixels from element top-left"),
+      y: import_zod14.z.number().describe("Y offset in pixels from element top-left")
     }).optional().describe("Omit for normal element-center interaction. Only provide when the user explicitly asks for an offset. Do not use { x: 0, y: 0 } for a normal button double-click/right-click; top-left is often intercepted."),
-    clickDelay: import_zod13.z.number().optional().describe("Omit when there is no requested delay. Only provide a positive value when the user explicitly asks for a delay.")
+    clickDelay: import_zod14.z.number().optional().describe("Omit when there is no requested delay. Only provide a positive value when the user explicitly asks for a delay.")
   })),
-  action("waitForUrl", "Wait for the page URL to match a glob pattern (web only)", import_zod13.z.object({
-    pattern: import_zod13.z.string().describe('URL glob pattern. Use "**" for substring matching (e.g., "**/dashboard**"). Plain strings WITHOUT wildcards require EXACT URL match, not substring.')
+  action("waitForUrl", "Wait for the page URL to match a glob pattern (web only)", import_zod14.z.object({
+    pattern: import_zod14.z.string().describe('URL glob pattern. Use "**" for substring matching (e.g., "**/dashboard**"). Plain strings WITHOUT wildcards require EXACT URL match, not substring.')
   })),
-  action("fileUpload", "Upload one or more files to a file input element (web only)", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference for the file input"),
-    files: import_zod13.z.array(import_zod13.z.string()).min(1).describe("Paths to files \u2014 relative to the test YAML file, or absolute paths. Missing files fail the action.")
+  action("fileUpload", "Upload one or more files to a file input element (web only)", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference for the file input"),
+    files: import_zod14.z.array(import_zod14.z.string()).min(1).describe("Paths to files \u2014 relative to the test YAML file, or absolute paths. Missing files fail the action.")
   })),
-  action("copy", "Copy the text content of an element to the system clipboard (web only, chromium only)", import_zod13.z.object({
-    ref: import_zod13.z.string().describe("Element reference whose text content to copy")
+  action("copy", "Copy the text content of an element to the system clipboard (web only, chromium only)", import_zod14.z.object({
+    ref: import_zod14.z.string().describe("Element reference whose text content to copy")
   }))
 ];
 function registerAllActions(registry) {
@@ -2631,9 +2710,9 @@ function buildExtractionPrompt(input, screenState) {
 }
 
 // src/agent/variables.ts
-var ExtractionResultSchema = import_zod14.z.object({
-  value: import_zod14.z.string(),
-  reasoning: import_zod14.z.string()
+var ExtractionResultSchema = import_zod15.z.object({
+  value: import_zod15.z.string(),
+  reasoning: import_zod15.z.string()
 });
 var VariableStore = class {
   storage = /* @__PURE__ */ new Map();
@@ -3133,11 +3212,11 @@ var LLMPlanner = class {
 
 // src/agent/verifier.ts
 var import_ai5 = require("ai");
-var import_zod15 = require("zod");
-var VerificationResultSchema = import_zod15.z.object({
-  success: import_zod15.z.boolean().describe("Whether the step goal was accomplished"),
-  reasoning: import_zod15.z.string().describe("Explanation of why the step succeeded or failed"),
-  isAppError: import_zod15.z.boolean().describe(
+var import_zod16 = require("zod");
+var VerificationResultSchema = import_zod16.z.object({
+  success: import_zod16.z.boolean().describe("Whether the step goal was accomplished"),
+  reasoning: import_zod16.z.string().describe("Explanation of why the step succeeded or failed"),
+  isAppError: import_zod16.z.boolean().describe(
     "Whether the page shows an application error (HTTP error, error toast, crash) vs the agent simply not accomplishing the goal"
   )
 });
@@ -3329,11 +3408,11 @@ async function createOpenAICompatibleModel(config) {
 
 // src/agent/asserter.ts
 var import_ai6 = require("ai");
-var import_zod16 = require("zod");
-var AssertionResultSchema = import_zod16.z.object({
-  passed: import_zod16.z.boolean(),
-  reasoning: import_zod16.z.string(),
-  evidence: import_zod16.z.string()
+var import_zod17 = require("zod");
+var AssertionResultSchema = import_zod17.z.object({
+  passed: import_zod17.z.boolean(),
+  reasoning: import_zod17.z.string(),
+  evidence: import_zod17.z.string()
 });
 var AssertionEvaluator = class {
   async evaluate(assertion, screenState) {
@@ -4962,6 +5041,192 @@ var RUNTIME_IMAGE_MAP = {
   bash: "vostride/agent-qa-hook-runner-bash"
 };
 
+// src/auth-state/hook-env.ts
+var AUTH_STATE_HOOK_JSON_ENV = "AGENT_QA_AUTH_STATE_JSON";
+var AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV = "AGENT_QA_AUTH_STATE_STORAGE_STATE_PATH";
+var AUTH_STATE_HOOK_WORKSPACE_DIR = ".agent-qa-auth-state";
+var AUTH_STATE_HOOK_STORAGE_STATE_FILENAME = "storage-state.json";
+var AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH = `/workspace/${AUTH_STATE_HOOK_WORKSPACE_DIR}/${AUTH_STATE_HOOK_STORAGE_STATE_FILENAME}`;
+var RESERVED_AUTH_STATE_HOOK_ENV_KEYS = /* @__PURE__ */ new Set([
+  AUTH_STATE_HOOK_JSON_ENV,
+  AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV
+]);
+function isReservedAuthStateHookEnvKey(key) {
+  return RESERVED_AUTH_STATE_HOOK_ENV_KEYS.has(key);
+}
+function stripReservedAuthStateHookEnv(variables) {
+  return Object.fromEntries(
+    Object.entries(variables).filter(([key]) => !isReservedAuthStateHookEnvKey(key))
+  );
+}
+function buildAuthStateHookEnv(authState, storageStatePath = AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH) {
+  if (!authState) return {};
+  const metadata = {
+    version: authState.version,
+    kind: authState.kind,
+    target: authState.targetName,
+    name: authState.stateName,
+    capturedAt: authState.capturedAt,
+    storageStatePath
+  };
+  return {
+    [AUTH_STATE_HOOK_JSON_ENV]: JSON.stringify(metadata),
+    [AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV]: storageStatePath
+  };
+}
+
+// src/auth-state/redaction.ts
+var AUTH_STATE_REDACTION_MARKER = "[auth state redacted]";
+var AUTH_STATE_JSON_KEY = normalizeKey(AUTH_STATE_HOOK_JSON_ENV);
+var AUTH_STATE_PATH_KEY = normalizeKey(AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV);
+var STRUCTURED_AUTH_STATE_KEYS = /* @__PURE__ */ new Set(["authstate", "auth_state"]);
+var STRUCTURED_PATH_KEYS = /* @__PURE__ */ new Set(["storagestatepath", AUTH_STATE_JSON_KEY, AUTH_STATE_PATH_KEY]);
+var AUTH_LIKE_KEY_RE = /(^|[_-])(token|cookie|authorization|csrf|session|bearer)([_-]|$)|^(token|cookie|authorization|csrf|session|bearer)$/i;
+function normalizeKey(key) {
+  return key.replace(/[\s-]/g, "").toLowerCase();
+}
+function isBufferLike2(value) {
+  return typeof Buffer !== "undefined" && Buffer.isBuffer(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isBufferLike2(value);
+}
+function isStorageStateShape(value) {
+  return isRecord(value) && Array.isArray(value.cookies) && Array.isArray(value.origins);
+}
+function isRuntimeAuthStateShape(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.storageStatePath === "string" && typeof value.stateName === "string" && typeof value.targetName === "string";
+}
+function isAuthStateManagementMetadata(value) {
+  if (!isRecord(value)) return false;
+  if ("storageStatePath" in value || "payloadPath" in value || "metadataPath" in value) return false;
+  return value.kind === "web" && typeof value.target === "string" && typeof value.name === "string" && typeof value.capturedAt === "string";
+}
+function isAuthStateManagementConfig(value) {
+  if (!isRecord(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => key === "dir");
+}
+function isAuthLikeCredentialKey(key) {
+  return AUTH_LIKE_KEY_RE.test(key);
+}
+function knownSensitiveStrings(context) {
+  const values = /* @__PURE__ */ new Set();
+  const hookStorageStatePath = context.hookStorageStatePath ?? AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH;
+  for (const value of [
+    AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH,
+    hookStorageStatePath,
+    context.storageStatePath,
+    context.authState?.storageStatePath,
+    context.hookJsonEnv
+  ]) {
+    if (typeof value === "string" && value.length > 0) values.add(value);
+  }
+  if (context.authState) {
+    const env = buildAuthStateHookEnv(context.authState, hookStorageStatePath);
+    const hookJson = env[AUTH_STATE_HOOK_JSON_ENV];
+    if (hookJson) values.add(hookJson);
+  }
+  return [...values].sort((left, right) => right.length - left.length);
+}
+function tryParseJsonObject(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function looksLikeStorageStateJson(value) {
+  if (!value.includes('"cookies"') || !value.includes('"origins"')) return false;
+  return isStorageStateShape(tryParseJsonObject(value));
+}
+function looksLikeAuthStateHookJson(value) {
+  if (!value.includes('"storageStatePath"')) return false;
+  const parsed = tryParseJsonObject(value);
+  return isRecord(parsed) && typeof parsed.storageStatePath === "string" && (typeof parsed.name === "string" || typeof parsed.target === "string" || parsed.kind === "web");
+}
+function redactStructuredAuthStateText(value) {
+  return value.replace(
+    /(\bauthState\s*:\s*\n(?:[ \t]+[^\n]*\n)*?[ \t]+name\s*:\s*)[^\n#]+/gi,
+    (_match, prefix) => `${prefix}${AUTH_STATE_REDACTION_MARKER}`
+  ).replace(
+    /(["']?(?:authState|auth_state|storageStatePath|AGENT_QA_AUTH_STATE_JSON|AGENT_QA_AUTH_STATE_STORAGE_STATE_PATH)["']?\s*[:=]\s*)(["'])[^"']*\2/gi,
+    (_match, prefix, quote) => `${prefix}${quote}${AUTH_STATE_REDACTION_MARKER}${quote}`
+  ).replace(
+    /((?:authState|auth_state|storageStatePath|AGENT_QA_AUTH_STATE_JSON|AGENT_QA_AUTH_STATE_STORAGE_STATE_PATH)\s*[:=]\s*)[^\s,}\]]+/gi,
+    (_match, prefix) => `${prefix}${AUTH_STATE_REDACTION_MARKER}`
+  );
+}
+function redactStorageStateJsonLines(value) {
+  return value.split(/\r?\n/).map((line) => {
+    const trimmed = line.trim();
+    return looksLikeStorageStateJson(trimmed) || looksLikeAuthStateHookJson(trimmed) ? AUTH_STATE_REDACTION_MARKER : line;
+  }).join("\n");
+}
+function redactAuthStateString(value, context = {}) {
+  if (value.includes(AUTH_STATE_HOOK_JSON_ENV) || value.includes(AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV) || looksLikeStorageStateJson(value.trim()) || looksLikeAuthStateHookJson(value.trim())) {
+    return AUTH_STATE_REDACTION_MARKER;
+  }
+  if (value.includes("authState") || value.includes("auth_state")) {
+    const parsed = tryParseJsonObject(value.trim());
+    if (parsed !== void 0) {
+      return JSON.stringify(redactAuthStateOnly(parsed, context));
+    }
+  }
+  let redacted = redactStorageStateJsonLines(value);
+  for (const sensitive of knownSensitiveStrings(context)) {
+    redacted = redacted.split(sensitive).join(AUTH_STATE_REDACTION_MARKER);
+  }
+  return redactStructuredAuthStateText(redacted);
+}
+function shouldRedactKeyValue(key, value, context) {
+  const normalized = normalizeKey(key);
+  if (STRUCTURED_PATH_KEYS.has(normalized)) return true;
+  if (STRUCTURED_AUTH_STATE_KEYS.has(normalized)) {
+    if (typeof value === "string") return true;
+    if (isAuthStateManagementConfig(value) || isAuthStateManagementMetadata(value)) return false;
+    return true;
+  }
+  if (typeof value === "string" && value.startsWith("[secret")) return false;
+  return context.redactAuthLikeKeys !== false && isAuthLikeCredentialKey(key);
+}
+function redactAuthStateOnly(value, context) {
+  if (typeof value === "string") {
+    return redactAuthStateString(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactAuthStateOnly(item, context));
+  }
+  if (isBufferLike2(value)) {
+    return value;
+  }
+  if (value instanceof Error) {
+    const redacted = new Error(redactAuthStateString(value.message, context));
+    redacted.name = value.name;
+    redacted.stack = value.stack ? redactAuthStateString(value.stack, context) : void 0;
+    return redacted;
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  if (isStorageStateShape(value) || isRuntimeAuthStateShape(value)) {
+    return AUTH_STATE_REDACTION_MARKER;
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (shouldRedactKeyValue(key, item, context)) {
+      result[key] = AUTH_STATE_REDACTION_MARKER;
+    } else {
+      result[key] = redactAuthStateOnly(item, context);
+    }
+  }
+  return result;
+}
+function redactAuthStateValue(value, context = {}) {
+  return redactAuthStateOnly(redactSecretValue(value, context.secretRedactor), context);
+}
+
 // src/hooks/sandbox-runner.ts
 var DEFAULT_DOCKER_BIN = "docker";
 function getHookCommand(runtime, entryFile) {
@@ -5005,12 +5270,18 @@ async function runHookInSandbox(hook, options = {}) {
     if (hook.packageFile) {
       await (0, import_promises4.cp)(hook.packageFile, (0, import_node_path4.join)(workDir, (0, import_node_path4.basename)(hook.packageFile)));
     }
+    if (options.authState) {
+      const authStateDir = (0, import_node_path4.join)(workDir, AUTH_STATE_HOOK_WORKSPACE_DIR);
+      await (0, import_promises4.mkdir)(authStateDir, { recursive: true });
+      await (0, import_promises4.cp)(options.authState.storageStatePath, (0, import_node_path4.join)(authStateDir, AUTH_STATE_HOOK_STORAGE_STATE_FILENAME));
+    }
     const args = buildDockerArgs({
       image,
       workDir,
       hook,
       envVars: options.envVars,
-      secretStore: options.secretStore
+      secretStore: options.secretStore,
+      authState: options.authState
     });
     const cmd = getHookCommand(hook.runtime, (0, import_node_path4.basename)(hook.file));
     args.push(...cmd);
@@ -5021,9 +5292,15 @@ async function runHookInSandbox(hook, options = {}) {
       variables = parseEnvFile(envContent);
     } catch {
     }
-    variables = filterSecretVariables(variables, options.secretStore);
-    const redactedStdout = redactSecretValue(stdout, options.secretRedactor);
-    const redactedStderr = redactSecretValue(stderr, options.secretRedactor);
+    variables = stripReservedAuthStateHookEnv(filterSecretVariables(variables, options.secretStore));
+    const redactedStdout = redactAuthStateValue(stdout, {
+      secretRedactor: options.secretRedactor,
+      authState: options.authState
+    });
+    const redactedStderr = redactAuthStateValue(stderr, {
+      secretRedactor: options.secretRedactor,
+      authState: options.authState
+    });
     const output = redactedStdout.trim();
     return {
       success: exitCode === 0,
@@ -5032,7 +5309,10 @@ async function runHookInSandbox(hook, options = {}) {
       stdout: redactedStdout,
       stderr: redactedStderr,
       duration: Date.now() - start,
-      error: exitCode !== 0 ? redactSecretValue(`Hook exited with code ${exitCode}: ${stderr}`, options.secretRedactor) : void 0
+      error: exitCode !== 0 ? redactAuthStateValue(`Hook exited with code ${exitCode}: ${stderr}`, {
+        secretRedactor: options.secretRedactor,
+        authState: options.authState
+      }) : void 0
     };
   } catch (err) {
     return {
@@ -5042,7 +5322,10 @@ async function runHookInSandbox(hook, options = {}) {
       stdout: "",
       stderr: "",
       duration: Date.now() - start,
-      error: redactSecretValue(err.message, options.secretRedactor)
+      error: redactAuthStateValue(err.message, {
+        secretRedactor: options.secretRedactor,
+        authState: options.authState
+      })
     };
   } finally {
     if (workDir) {
@@ -5077,6 +5360,10 @@ function buildDockerArgs(input) {
   input.secretStore?.forEachSecret((name, value) => {
     envVars[name] = value;
   });
+  Object.assign(envVars, buildAuthStateHookEnv(
+    input.authState,
+    AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH
+  ));
   for (const [k, v] of Object.entries(envVars)) {
     args.push("-e", `${k}=${v}`);
   }
@@ -5742,7 +6029,9 @@ ${errorLines.join("\n")}`;
     videoPath,
     failureSummary: failureSummary || void 0
   };
-  await reporter?.onTestEnd(testResult);
+  if (config.skipReporterOnTestEnd !== true) {
+    await reporter?.onTestEnd(testResult);
+  }
   return testResult;
 }
 function createTimeoutStepResult(name, scopeLabel, timeoutMs) {
@@ -7228,46 +7517,261 @@ 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
+// src/auth-state/resolver.ts
+var import_node_path9 = __toESM(require("path"), 1);
+
+// src/runtime-paths.ts
+var DEFAULT_AGENT_QA_RUNTIME_DIR = ".agent-qa";
+var DEFAULT_AGENT_QA_ARTIFACTS_DIR = ".agent-qa/artifacts";
+var DEFAULT_AGENT_QA_CACHE_DIR = ".agent-qa/cache";
+var DEFAULT_AGENT_QA_AUTH_STATES_DIR = ".agent-qa/auth-states";
+var DEFAULT_AGENT_QA_SCREENSHOTS_DIR = ".agent-qa/artifacts/screenshots";
+var DEFAULT_AGENT_QA_VIDEOS_DIR = ".agent-qa/artifacts/videos";
+var DEFAULT_AGENT_QA_RUNS_DB_PATH = ".agent-qa/runs.db";
+var LEGACY_AGENT_QA_DASHBOARD_DB_PATH = ".agent-qa/dashboard.db";
+
+// src/auth-state/resolver.ts
+var MOBILE_AUTH_STATE_ERROR = [
+  "auth state is only supported for web targets.",
+  "For native mobile, use use.mobile.appState: preserve when keeping app data between sessions.",
+  "App-state preservation is broader than auth and does not export generic secure-storage/keychain tokens."
+].join(" ");
+function assertInsideRoot(rootDir, filePath) {
+  const relativePath = import_node_path9.default.relative(rootDir, filePath);
+  if (!relativePath || relativePath.startsWith("..") || import_node_path9.default.isAbsolute(relativePath)) {
+    throw new Error(`Resolved auth-state path escapes auth-state directory: ${filePath}`);
+  }
+}
+function resolveAuthStateRoot(input) {
+  const { configDir, authStateDir } = input;
+  const configuredDir = authStateDir ?? DEFAULT_AGENT_QA_AUTH_STATES_DIR;
+  if (configuredDir.trim().length === 0) {
+    throw new Error("authState.dir must be a non-empty path");
+  }
+  return import_node_path9.default.isAbsolute(configuredDir) ? import_node_path9.default.resolve(configuredDir) : import_node_path9.default.resolve(configDir, configuredDir);
+}
+function resolveAuthStatePaths(input) {
+  const targetName = TargetNameSchema.parse(input.targetName);
+  const stateName = AuthStateNameSchema.parse(input.stateName);
+  const platform = input.target?.platform ?? input.platform;
+  if (platform !== "web") {
+    throw new Error(MOBILE_AUTH_STATE_ERROR);
+  }
+  const rootDir = resolveAuthStateRoot({
+    configDir: input.configDir,
+    authStateDir: input.authStateDir
+  });
+  const targetDir = import_node_path9.default.join(rootDir, targetName);
+  const payloadPath = import_node_path9.default.join(targetDir, `${stateName}.json`);
+  const metadataPath = import_node_path9.default.join(targetDir, `${stateName}.meta.json`);
+  assertInsideRoot(rootDir, payloadPath);
+  assertInsideRoot(rootDir, metadataPath);
+  return {
+    targetName,
+    stateName,
+    rootDir,
+    targetDir,
+    payloadPath,
+    metadataPath
+  };
+}
+
+// src/auth-state/store.ts
+var import_node_crypto3 = require("crypto");
 var import_promises7 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_node_path10 = __toESM(require("path"), 1);
+function assertMetadataMatches(paths, metadata) {
+  if (metadata.target !== paths.targetName) {
+    throw new Error(`Auth-state metadata target "${metadata.target}" does not match resolved target "${paths.targetName}"`);
+  }
+  if (metadata.name !== paths.stateName) {
+    throw new Error(`Auth-state metadata name "${metadata.name}" does not match resolved state "${paths.stateName}"`);
+  }
+}
+async function writeJsonAtomic(filePath, value) {
+  const serialized = `${JSON.stringify(value, null, 2)}
+`;
+  const directory = import_node_path10.default.dirname(filePath);
+  const tempPath = import_node_path10.default.join(directory, `.${import_node_path10.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto3.randomUUID)()}.tmp`);
+  await (0, import_promises7.mkdir)(directory, { recursive: true });
+  try {
+    await (0, import_promises7.writeFile)(tempPath, serialized, { mode: 384 });
+    await (0, import_promises7.rename)(tempPath, filePath);
+  } catch (error) {
+    await (0, import_promises7.rm)(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function readAuthStateMetadata(paths) {
+  let raw;
+  try {
+    raw = await (0, import_promises7.readFile)(paths.metadataPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Auth-state metadata not found: ${paths.metadataPath}`);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid auth-state metadata JSON: ${paths.metadataPath}`);
+  }
+  const result = AuthStateMetadataSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`Invalid auth-state metadata: ${result.error.issues.map((issue) => issue.message).join("; ")}`);
+  }
+  assertMetadataMatches(paths, result.data);
+  return result.data;
+}
+async function writeAuthStateFiles(paths, input) {
+  const metadata = AuthStateMetadataSchema.parse(input.metadata);
+  assertMetadataMatches(paths, metadata);
+  await writeJsonAtomic(paths.payloadPath, input.payload);
+  await writeJsonAtomic(paths.metadataPath, metadata);
+}
+async function listAuthStateMetadata(input) {
+  const rootDir = resolveAuthStateRoot({
+    configDir: input.configDir,
+    authStateDir: input.authStateDir
+  });
+  const targetFilter = input.targetName ? TargetNameSchema.parse(input.targetName) : void 0;
+  let targetEntries;
+  try {
+    targetEntries = await (0, import_promises7.readdir)(rootDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const metadata = [];
+  for (const targetEntry of targetEntries) {
+    if (!targetEntry.isDirectory()) continue;
+    const targetNameResult = TargetNameSchema.safeParse(targetEntry.name);
+    if (!targetNameResult.success) continue;
+    const targetName = targetNameResult.data;
+    if (targetFilter && targetName !== targetFilter) continue;
+    let stateEntries;
+    const targetDir = import_node_path10.default.join(rootDir, targetName);
+    try {
+      stateEntries = await (0, import_promises7.readdir)(targetDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const stateEntry of stateEntries) {
+      if (!stateEntry.isFile() || !stateEntry.name.endsWith(".meta.json")) continue;
+      const stateName = stateEntry.name.slice(0, -".meta.json".length);
+      const paths = (() => {
+        try {
+          return resolveAuthStatePaths({
+            configDir: input.configDir,
+            authStateDir: input.authStateDir,
+            targetName,
+            stateName,
+            platform: "web"
+          });
+        } catch {
+          return null;
+        }
+      })();
+      if (!paths) continue;
+      try {
+        const entry = await readAuthStateMetadata(paths);
+        metadata.push(entry);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return metadata.sort((a, b) => {
+    const targetOrder = a.target.localeCompare(b.target);
+    return targetOrder === 0 ? a.name.localeCompare(b.name) : targetOrder;
+  });
+}
+async function removeAuthStateFiles(input) {
+  const paths = resolveAuthStatePaths(input);
+  await (0, import_promises7.rm)(paths.payloadPath, { force: true });
+  await (0, import_promises7.rm)(paths.metadataPath, { force: true });
+}
+async function removeAuthStateTarget(input) {
+  const paths = resolveAuthStatePaths({
+    ...input,
+    stateName: "placeholder"
+  });
+  await (0, import_promises7.rm)(paths.targetDir, { recursive: true, force: true });
+}
+
+// src/auth-state/runtime.ts
+var import_promises8 = require("fs/promises");
+function createAuthStateReadError(targetName, stateName) {
+  return new Error(
+    `Auth state "${stateName}" for target "${targetName}" was not found or could not be read. Run agent-qa auth-state capture --target ${targetName} --name ${stateName}.`
+  );
+}
+async function assertPayloadReadable(paths) {
+  const raw = await (0, import_promises8.readFile)(paths.payloadPath, "utf-8");
+  JSON.parse(raw);
+}
+async function resolveAuthStateForRun(input) {
+  const paths = resolveAuthStatePaths(input);
+  try {
+    const metadata = await readAuthStateMetadata(paths);
+    await assertPayloadReadable(paths);
+    return {
+      version: metadata.version,
+      kind: metadata.kind,
+      targetName: metadata.target,
+      stateName: metadata.name,
+      capturedAt: metadata.capturedAt,
+      storageStatePath: paths.payloadPath
+    };
+  } catch {
+    throw createAuthStateReadError(paths.targetName, paths.stateName);
+  }
+}
+
+// src/auth/store.ts
+var import_promises9 = require("fs/promises");
+var import_node_path11 = require("path");
 var import_node_os2 = require("os");
 function getAuthPath() {
   const xdg = process.env.XDG_DATA_HOME;
-  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");
+  if (xdg) return (0, import_node_path11.join)(xdg, "agent-qa", "auth.json");
+  return (0, import_node_path11.join)((0, import_node_os2.homedir)(), ".agent-qa", "auth.json");
 }
-async function readAuth(path5) {
-  const authPath = path5 ?? getAuthPath();
+async function readAuth(path7) {
+  const authPath = path7 ?? getAuthPath();
   try {
-    const data = await (0, import_promises7.readFile)(authPath, "utf-8");
+    const data = await (0, import_promises9.readFile)(authPath, "utf-8");
     return JSON.parse(data);
   } catch {
     return {};
   }
 }
-async function writeAuth(provider, credential, path5) {
-  const authPath = path5 ?? getAuthPath();
+async function writeAuth(provider, credential, path7) {
+  const authPath = path7 ?? getAuthPath();
   const store = await readAuth(authPath);
   store[provider] = credential;
-  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 });
+  await (0, import_promises9.mkdir)((0, import_node_path11.dirname)(authPath), { recursive: true });
+  await (0, import_promises9.writeFile)(authPath, JSON.stringify(store, null, 2), { mode: 384 });
 }
-async function removeAuth(provider, path5) {
-  const authPath = path5 ?? getAuthPath();
+async function removeAuth(provider, path7) {
+  const authPath = path7 ?? getAuthPath();
   const store = await readAuth(authPath);
   delete store[provider];
   if (Object.keys(store).length === 0) {
     try {
-      await (0, import_promises7.unlink)(authPath);
+      await (0, import_promises9.unlink)(authPath);
     } catch {
     }
     return;
   }
-  await (0, import_promises7.writeFile)(authPath, JSON.stringify(store, null, 2), { mode: 384 });
+  await (0, import_promises9.writeFile)(authPath, JSON.stringify(store, null, 2), { mode: 384 });
 }
-async function getCredential(provider, path5) {
-  const store = await readAuth(path5);
+async function getCredential(provider, path7) {
+  const store = await readAuth(path7);
   return store[provider] ?? null;
 }
 
@@ -7429,16 +7933,16 @@ async function resolveLLMAuth(configName, llmConfig, authPath) {
 // src/auth/plugin-loader.ts
 var import_node_module = require("module");
 var import_node_fs3 = require("fs");
-var import_node_path10 = require("path");
+var import_node_path12 = 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_path10.resolve)(baseDir);
+  let current = (0, import_node_path12.resolve)(baseDir);
   while (true) {
-    const candidate = (0, import_node_path10.resolve)(current, "node_modules", ...packageName.split("/"), "package.json");
+    const candidate = (0, import_node_path12.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);
+    const parent = (0, import_node_path12.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -7466,7 +7970,7 @@ function resolvePackageImportFromBase(packageName, baseDir) {
   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_path10.resolve)((0, import_node_path10.dirname)(packageJsonPath), target)).href;
+  return (0, import_node_url.pathToFileURL)((0, import_node_path12.resolve)((0, import_node_path12.dirname)(packageJsonPath), target)).href;
 }
 function packageDeclarationValue(declaration) {
   return "package" in declaration && typeof declaration.package === "string" ? declaration.package.trim() : "";
@@ -7477,24 +7981,24 @@ function pathDeclarationValue(declaration) {
 function declarationKey(declaration, baseDir) {
   const packageName = packageDeclarationValue(declaration);
   if (packageName) return `package:${packageName}`;
-  return `path:${(0, import_node_path10.resolve)(baseDir, pathDeclarationValue(declaration))}`;
+  return `path:${(0, import_node_path12.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_path10.resolve)(baseDir, "agent-qa.config.yaml")).href;
+    const parentUrl = (0, import_node_url.pathToFileURL)((0, import_node_path12.resolve)(baseDir, "agent-qa.config.yaml")).href;
     try {
       const resolveImport = import_meta.resolve;
       return resolveImport(packageName, parentUrl);
     } catch {
-      const require4 = (0, import_node_module.createRequire)((0, import_node_path10.resolve)(baseDir, "agent-qa.config.yaml"));
+      const require4 = (0, import_node_module.createRequire)((0, import_node_path12.resolve)(baseDir, "agent-qa.config.yaml"));
       return (0, import_node_url.pathToFileURL)(require4.resolve(packageName)).href;
     }
   }
   const pluginPath = pathDeclarationValue(declaration);
-  const absolutePath = (0, import_node_path10.isAbsolute)(pluginPath) ? pluginPath : (0, import_node_path10.resolve)(baseDir, pluginPath);
+  const absolutePath = (0, import_node_path12.isAbsolute)(pluginPath) ? pluginPath : (0, import_node_path12.resolve)(baseDir, pluginPath);
   return (0, import_node_url.pathToFileURL)(absolutePath).href;
 }
 async function resolvePluginBundle(module2, source) {
@@ -7556,14 +8060,14 @@ function clearLoadedLLMAuthPluginModules() {
 }
 
 // src/auth/pkce.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 function generatePKCE() {
-  const verifier = (0, import_node_crypto3.randomBytes)(32).toString("base64url");
-  const challenge = (0, import_node_crypto3.createHash)("sha256").update(verifier).digest("base64url");
+  const verifier = (0, import_node_crypto4.randomBytes)(32).toString("base64url");
+  const challenge = (0, import_node_crypto4.createHash)("sha256").update(verifier).digest("base64url");
   return { verifier, challenge };
 }
 function generateState() {
-  return (0, import_node_crypto3.randomBytes)(16).toString("hex");
+  return (0, import_node_crypto4.randomBytes)(16).toString("hex");
 }
 
 // src/auth/fetch-wrapper.ts
@@ -7626,7 +8130,7 @@ function createAuthFetch(options) {
 }
 
 // src/logging/types.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var LOG_LEVEL_PRIORITY = {
   silent: 0,
   error: 1,
@@ -7634,53 +8138,53 @@ var LOG_LEVEL_PRIORITY = {
   info: 3,
   debug: 4
 };
-var AgentLogDataSchema = import_zod17.z.object({
-  extractDom: import_zod17.z.boolean().optional(),
-  hasScreenshot: import_zod17.z.boolean().optional(),
-  duration: import_zod17.z.number().optional(),
-  elementCount: import_zod17.z.number().optional()
+var AgentLogDataSchema = import_zod18.z.object({
+  extractDom: import_zod18.z.boolean().optional(),
+  hasScreenshot: import_zod18.z.boolean().optional(),
+  duration: import_zod18.z.number().optional(),
+  elementCount: import_zod18.z.number().optional()
 });
-var AdapterLogDataSchema = import_zod17.z.object({
-  actionType: import_zod17.z.string().optional(),
-  selector: import_zod17.z.string().optional(),
-  coordinates: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional(),
-  elementProperties: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional(),
-  duration: import_zod17.z.number().optional()
+var AdapterLogDataSchema = import_zod18.z.object({
+  actionType: import_zod18.z.string().optional(),
+  selector: import_zod18.z.string().optional(),
+  coordinates: import_zod18.z.object({ x: import_zod18.z.number(), y: import_zod18.z.number() }).optional(),
+  elementProperties: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).optional(),
+  duration: import_zod18.z.number().optional()
 });
-var CacheLogDataSchema = import_zod17.z.object({
-  operation: import_zod17.z.enum(["get", "set", "invalidate", "bypass", "batch-purge"]),
-  stepHash: import_zod17.z.string().optional(),
-  screenHash: import_zod17.z.string().optional(),
-  hit: import_zod17.z.boolean().optional(),
-  age: import_zod17.z.number().optional(),
-  entriesDeleted: import_zod17.z.number().optional()
+var CacheLogDataSchema = import_zod18.z.object({
+  operation: import_zod18.z.enum(["get", "set", "invalidate", "bypass", "batch-purge"]),
+  stepHash: import_zod18.z.string().optional(),
+  screenHash: import_zod18.z.string().optional(),
+  hit: import_zod18.z.boolean().optional(),
+  age: import_zod18.z.number().optional(),
+  entriesDeleted: import_zod18.z.number().optional()
 });
-var PlannerLogDataSchema = import_zod17.z.object({
-  model: import_zod17.z.string().optional(),
-  promptTokens: import_zod17.z.number().optional(),
-  completionTokens: import_zod17.z.number().optional(),
-  latencyMs: import_zod17.z.number().optional(),
-  confidence: import_zod17.z.number().optional(),
-  actionType: import_zod17.z.string().optional()
+var PlannerLogDataSchema = import_zod18.z.object({
+  model: import_zod18.z.string().optional(),
+  promptTokens: import_zod18.z.number().optional(),
+  completionTokens: import_zod18.z.number().optional(),
+  latencyMs: import_zod18.z.number().optional(),
+  confidence: import_zod18.z.number().optional(),
+  actionType: import_zod18.z.string().optional()
 });
-var HealerLogDataSchema = import_zod17.z.object({
-  strategy: import_zod17.z.string().optional(),
-  attempt: import_zod17.z.number().optional(),
-  maxAttempts: import_zod17.z.number().optional(),
-  stateDiffDetected: import_zod17.z.boolean().optional(),
-  success: import_zod17.z.boolean().optional()
+var HealerLogDataSchema = import_zod18.z.object({
+  strategy: import_zod18.z.string().optional(),
+  attempt: import_zod18.z.number().optional(),
+  maxAttempts: import_zod18.z.number().optional(),
+  stateDiffDetected: import_zod18.z.boolean().optional(),
+  success: import_zod18.z.boolean().optional()
 });
-var HookLogDataSchema = import_zod17.z.object({
-  hookName: import_zod17.z.string().optional(),
-  phase: import_zod17.z.enum(["setup", "teardown"]).optional(),
-  duration: import_zod17.z.number().optional(),
-  success: import_zod17.z.boolean().optional()
+var HookLogDataSchema = import_zod18.z.object({
+  hookName: import_zod18.z.string().optional(),
+  phase: import_zod18.z.enum(["setup", "teardown"]).optional(),
+  duration: import_zod18.z.number().optional(),
+  success: import_zod18.z.boolean().optional()
 });
-var RunnerLogDataSchema = import_zod17.z.object({
-  stepIndex: import_zod17.z.number().optional(),
-  totalSteps: import_zod17.z.number().optional(),
-  testName: import_zod17.z.string().optional(),
-  variablesCaptured: import_zod17.z.number().optional()
+var RunnerLogDataSchema = import_zod18.z.object({
+  stepIndex: import_zod18.z.number().optional(),
+  totalSteps: import_zod18.z.number().optional(),
+  testName: import_zod18.z.string().optional(),
+  variablesCaptured: import_zod18.z.number().optional()
 });
 var LogSourceDataSchemas = {
   agent: AgentLogDataSchema,
@@ -7693,7 +8197,7 @@ var LogSourceDataSchemas = {
 };
 
 // src/logging/log-manager.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 
 // src/logging/cli-formatter.ts
 var import_picocolors3 = __toESM(require("picocolors"), 1);
@@ -7735,13 +8239,13 @@ var LogManager = class {
   }
   log(level, source, message, data) {
     const entry = {
-      id: (0, import_node_crypto4.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       stepId: this.currentStepId,
       runId: this.runId,
       level,
       source,
-      message: redactSecretValue(message, this.redactor),
-      data: redactSecretValue(data ?? {}, this.redactor),
+      message: redactAuthStateValue(message, { secretRedactor: this.redactor }),
+      data: redactAuthStateValue(data ?? {}, { secretRedactor: this.redactor }),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.buffer.push(entry);
@@ -7885,7 +8389,7 @@ function mapMobileCapabilities(match, platform, credentials, opts) {
 
 // src/farm/browserstack.ts
 var import_node_fs4 = require("fs");
-var import_node_path11 = require("path");
+var import_node_path13 = require("path");
 function isAbsoluteAppValue(value) {
   return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 }
@@ -7904,7 +8408,7 @@ async function resolveBrowserStackApp(config) {
     });
   }
   const appBaseDir = config.appBaseDir ?? process.cwd();
-  const resolvedPath = (0, import_node_path11.resolve)(appBaseDir, config.app);
+  const resolvedPath = (0, import_node_path13.resolve)(appBaseDir, config.app);
   const mustExist = isExplicitRelativePath(config.app);
   if (!(0, import_node_fs4.existsSync)(resolvedPath)) {
     if (mustExist) {
@@ -7920,7 +8424,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_fs4.readFileSync)(resolvedPath)]), (0, import_node_path11.basename)(resolvedPath));
+  form.append("file", new Blob([(0, import_node_fs4.readFileSync)(resolvedPath)]), (0, import_node_path13.basename)(resolvedPath));
   let res;
   try {
     res = await fetch("https://api-cloud.browserstack.com/app-automate/upload", {
@@ -8057,8 +8561,8 @@ function registerAllProviders() {
 }
 
 // src/suite/runner.ts
-var import_node_crypto5 = require("crypto");
-var import_promises10 = require("fs/promises");
+var import_node_crypto6 = require("crypto");
+var import_promises12 = require("fs/promises");
 
 // src/hooks/orchestrator.ts
 async function runHooks(hooks, options = {}) {
@@ -8070,7 +8574,7 @@ async function runHooks(hooks, options = {}) {
     const result = await runHookInSandbox(hook, { ...options, envVars });
     results.set(hook.name, result);
     if (result.success) {
-      Object.assign(mergedVars, result.variables);
+      Object.assign(mergedVars, stripReservedAuthStateHookEnv(result.variables));
     } else {
       for (const remaining of hooks.slice(hooks.indexOf(hook) + 1)) {
         results.set(remaining.name, {
@@ -8096,9 +8600,9 @@ async function runHooks(hooks, options = {}) {
 
 // src/memory/curator.ts
 var import_ai7 = require("ai");
-var import_zod19 = require("zod");
-var import_node_path13 = require("path");
-var import_promises9 = require("fs/promises");
+var import_zod20 = require("zod");
+var import_node_path15 = require("path");
+var import_promises11 = require("fs/promises");
 init_observation_io();
 
 // src/memory/observation-id.ts
@@ -8106,31 +8610,31 @@ var import_agent_qa_ids6 = require("@vostride/agent-qa-ids");
 
 // src/memory/curator.ts
 init_security_scanner();
-var CuratorActionSchema = import_zod19.z.discriminatedUnion("action", [
-  import_zod19.z.object({
-    action: import_zod19.z.literal("add"),
-    title: import_zod19.z.string().min(1),
-    content: import_zod19.z.string().min(1),
-    scope: import_zod19.z.enum(["product", "suite", "test"]).describe('Use "suite" only if a suite context was provided'),
-    reasoning: import_zod19.z.string()
+var CuratorActionSchema = import_zod20.z.discriminatedUnion("action", [
+  import_zod20.z.object({
+    action: import_zod20.z.literal("add"),
+    title: import_zod20.z.string().min(1),
+    content: import_zod20.z.string().min(1),
+    scope: import_zod20.z.enum(["product", "suite", "test"]).describe('Use "suite" only if a suite context was provided'),
+    reasoning: import_zod20.z.string()
   }),
-  import_zod19.z.object({
-    action: import_zod19.z.literal("update"),
-    observationId: import_zod19.z.string(),
-    reasoning: import_zod19.z.string()
+  import_zod20.z.object({
+    action: import_zod20.z.literal("update"),
+    observationId: import_zod20.z.string(),
+    reasoning: import_zod20.z.string()
   }),
-  import_zod19.z.object({
-    action: import_zod19.z.literal("deprecate"),
-    observationId: import_zod19.z.string(),
-    reasoning: import_zod19.z.string()
+  import_zod20.z.object({
+    action: import_zod20.z.literal("deprecate"),
+    observationId: import_zod20.z.string(),
+    reasoning: import_zod20.z.string()
   }),
-  import_zod19.z.object({
-    action: import_zod19.z.literal("noop"),
-    reasoning: import_zod19.z.string()
+  import_zod20.z.object({
+    action: import_zod20.z.literal("noop"),
+    reasoning: import_zod20.z.string()
   })
 ]);
-var CuratorResponseSchema = import_zod19.z.object({
-  decisions: import_zod19.z.array(CuratorActionSchema)
+var CuratorResponseSchema = import_zod20.z.object({
+  decisions: import_zod20.z.array(CuratorActionSchema)
 });
 function emptyLog() {
   return { added: 0, confirmed: 0, deprecated: 0, deleted: 0, deltas: [], errors: [], curatorDuration: 0 };
@@ -8246,17 +8750,17 @@ function collectKnownObservationIds(injectedObservationIds, dedupMatches) {
 async function findObservationFile(memoryRoot, id) {
   const tiers = ["products", "suites", "tests"];
   for (const tier of tiers) {
-    const tierDir = (0, import_node_path13.join)(memoryRoot, tier);
+    const tierDir = (0, import_node_path15.join)(memoryRoot, tier);
     let scopes;
     try {
-      scopes = await (0, import_promises9.readdir)(tierDir);
+      scopes = await (0, import_promises11.readdir)(tierDir);
     } catch {
       continue;
     }
     for (const scope of scopes) {
-      const filePath = (0, import_node_path13.join)(tierDir, scope, `${id}.md`);
+      const filePath = (0, import_node_path15.join)(tierDir, scope, `${id}.md`);
       try {
-        await (0, import_promises9.access)(filePath);
+        await (0, import_promises11.access)(filePath);
         return { tier, scope, filePath };
       } catch {
         continue;
@@ -8267,7 +8771,7 @@ async function findObservationFile(memoryRoot, id) {
 }
 async function readAndParseObservation(filePath, id) {
   try {
-    const raw = await (0, import_promises9.readFile)(filePath, "utf-8");
+    const raw = await (0, import_promises11.readFile)(filePath, "utf-8");
     const { data, error } = parseObservation(raw, `${id}.md`);
     if (!data || error) return null;
     return { data, raw };
@@ -8483,12 +8987,12 @@ ${userMessage}`;
       }
       if (ctx.suiteId && ctx.suiteContext) {
         try {
-          const suiteDir = (0, import_node_path13.join)(ctx.memoryRoot, "suites", ctx.suiteId);
+          const suiteDir = (0, import_node_path15.join)(ctx.memoryRoot, "suites", ctx.suiteId);
           const files = await listObservations(suiteDir);
           for (const file of files) {
             try {
-              const filePath = (0, import_node_path13.join)(suiteDir, file);
-              const raw = await (0, import_promises9.readFile)(filePath, "utf-8");
+              const filePath = (0, import_node_path15.join)(suiteDir, file);
+              const raw = await (0, import_promises11.readFile)(filePath, "utf-8");
               const { data } = parseObservation(raw, file);
               if (!data || !("suite_snapshot" in data)) continue;
               const suiteObs = data;
@@ -8690,6 +9194,7 @@ async function runSuite(suite, testEntries, config) {
   const results = [];
   const reporter = config.reporters?.length ? new MultiReporter(config.reporters) : void 0;
   const suiteRunId = config.runId ?? process.env.AGENT_QA_SUITE_QUEUE_ID ?? generateRunId();
+  let suiteSandboxOptions = config.sandboxOptions && config.platformConfig.authState ? { ...config.sandboxOptions, authState: config.platformConfig.authState } : config.sandboxOptions;
   const suiteArtifact = config.artifactContext?.artifact ?? config.artifactContext;
   await reporter?.onSuiteStart(suite, {
     runId: suiteRunId,
@@ -8725,7 +9230,7 @@ async function runSuite(suite, testEntries, config) {
     return { runId: suiteRunId, name: suite.name, status: "failed", tests: earlyResults, duration: duration2, failedAt: 0 };
   };
   let suiteHookVars = {};
-  if (suite.setup?.length && config.resolvedHooks && config.sandboxOptions) {
+  if (suite.setup?.length && config.resolvedHooks && suiteSandboxOptions) {
     const hookDefs = [];
     let hookMissing = false;
     for (const hookId of suite.setup) {
@@ -8744,14 +9249,14 @@ async function runSuite(suite, testEntries, config) {
     if (config.inlineVars) Object.assign(envVars, config.inlineVars);
     if (config.cliVars) Object.assign(envVars, config.cliVars);
     const result = await runHooks(hookDefs, {
-      ...config.sandboxOptions,
+      ...suiteSandboxOptions,
       secretStore: config.secretStore,
       secretRedactor: config.secretRedactor,
-      envVars: { ...config.sandboxOptions.envVars, ...envVars }
+      envVars: { ...suiteSandboxOptions.envVars, ...envVars }
     });
     for (const [name, hr] of result.results) {
       const hookDef = hookDefs.find((hook) => hook.name === name);
-      const hookExecId = (0, import_node_crypto5.randomUUID)();
+      const hookExecId = (0, import_node_crypto6.randomUUID)();
       await reporter?.onHookStart?.({ hookId: hookDef?.id, hookName: name, phase: "setup", hookExecutionId: hookExecId, runId: suiteRunId });
       await reporter?.onHookEnd?.({
         hookId: hookDef?.id,
@@ -8847,7 +9352,7 @@ async function runSuite(suite, testEntries, config) {
         });
         let perTestHookVars = {};
         let perTestSetupFailed = false;
-        if (patched.setup?.length && config.resolvedHooks && config.sandboxOptions) {
+        if (patched.setup?.length && config.resolvedHooks && suiteSandboxOptions) {
           const hookDefs = [];
           let hookMissing = false;
           for (const hookId of patched.setup) {
@@ -8865,13 +9370,13 @@ async function runSuite(suite, testEntries, config) {
             if (config.cliVars) Object.assign(allVars, config.cliVars);
             Object.assign(allVars, suiteHookVars);
             for (const hookDef of hookDefs) {
-              const hookExecId = (0, import_node_crypto5.randomUUID)();
+              const hookExecId = (0, import_node_crypto6.randomUUID)();
               await reporter?.onHookStart?.({ hookId: hookDef.id, hookName: hookDef.name, phase: "setup", hookExecutionId: hookExecId, runId: childRunId });
               const hookResult = await runHooks([hookDef], {
-                ...config.sandboxOptions,
+                ...suiteSandboxOptions,
                 secretStore: config.secretStore,
                 secretRedactor: config.secretRedactor,
-                envVars: { ...config.sandboxOptions.envVars, ...allVars, ...perTestHookVars }
+                envVars: { ...suiteSandboxOptions.envVars, ...allVars, ...perTestHookVars }
               });
               const hr = hookResult.results.get(hookDef.name);
               await reporter?.onHookEnd?.({
@@ -8913,7 +9418,7 @@ async function runSuite(suite, testEntries, config) {
         }
         let testFileContent = "";
         try {
-          testFileContent = await (0, import_promises10.readFile)(filePath, "utf-8");
+          testFileContent = await (0, import_promises12.readFile)(filePath, "utf-8");
         } catch {
         }
         const memoryInitParams = memoryEnabled ? {
@@ -8948,7 +9453,7 @@ async function runSuite(suite, testEntries, config) {
           cliVars: config.cliVars,
           hookSetupVars: perTestHookVars,
           inlineHookDefs: config.resolvedHooks,
-          inlineHookSandboxOptions: config.sandboxOptions,
+          inlineHookSandboxOptions: suiteSandboxOptions,
           secretStore: config.secretStore,
           secretRedactor: config.secretRedactor,
           accessibility: config.accessibility,
@@ -8964,11 +9469,11 @@ async function runSuite(suite, testEntries, config) {
           parentRunId: suiteRunId
         }, filePath);
         if (!result.runId) result.runId = childRunId;
-        if (patched.teardown?.length && config.resolvedHooks && config.sandboxOptions) {
+        if (patched.teardown?.length && config.resolvedHooks && suiteSandboxOptions) {
           for (const hookId of patched.teardown) {
             const hook = config.resolvedHooks.get(hookId);
             if (!hook) continue;
-            const hookExecId = (0, import_node_crypto5.randomUUID)();
+            const hookExecId = (0, import_node_crypto6.randomUUID)();
             try {
               await reporter?.onHookStart?.({ hookId: hook.id, hookName: hook.name, phase: "teardown", hookExecutionId: hookExecId, runId: childRunId });
               const teardownVars = {};
@@ -8976,10 +9481,10 @@ async function runSuite(suite, testEntries, config) {
               if (config.cliVars) Object.assign(teardownVars, config.cliVars);
               Object.assign(teardownVars, suiteHookVars, perTestHookVars);
               const hookResult = await runHooks([hook], {
-                ...config.sandboxOptions,
+                ...suiteSandboxOptions,
                 secretStore: config.secretStore,
                 secretRedactor: config.secretRedactor,
-                envVars: { ...config.sandboxOptions.envVars, ...teardownVars }
+                envVars: { ...suiteSandboxOptions.envVars, ...teardownVars }
               });
               const hr = hookResult.results.get(hook.name);
               await reporter?.onHookEnd?.({
@@ -9116,8 +9621,27 @@ async function runSuite(suite, testEntries, config) {
         }
       }
     }
+    if (config.authStateCapture && results.length > 0 && results.every((result) => result.status === "passed")) {
+      try {
+        const capturedAuthState = await config.authStateCapture.capture();
+        suiteSandboxOptions = config.sandboxOptions ? { ...config.sandboxOptions, authState: capturedAuthState } : config.sandboxOptions;
+      } catch {
+        const captureFailureResult = {
+          runId: suiteRunId,
+          name: "Auth state capture",
+          filePath: "",
+          status: "failed",
+          steps: [],
+          duration: 0,
+          failureSummary: config.authStateCapture.failureSummary,
+          metadata: { phase: "auth-state-capture" }
+        };
+        results.push(captureFailureResult);
+        await reporter?.onTestEnd(captureFailureResult);
+      }
+    }
   } finally {
-    if (suite.teardown?.length && config.resolvedHooks && config.sandboxOptions) {
+    if (suite.teardown?.length && config.resolvedHooks && suiteSandboxOptions) {
       const teardownVars = {};
       if (config.envFileVars) Object.assign(teardownVars, config.envFileVars);
       if (config.inlineVars) Object.assign(teardownVars, config.inlineVars);
@@ -9126,14 +9650,14 @@ async function runSuite(suite, testEntries, config) {
       for (const hookId of suite.teardown) {
         const hook = config.resolvedHooks.get(hookId);
         if (!hook) continue;
-        const hookExecId = (0, import_node_crypto5.randomUUID)();
+        const hookExecId = (0, import_node_crypto6.randomUUID)();
         try {
           await reporter?.onHookStart?.({ hookId: hook.id, hookName: hook.name, phase: "teardown", hookExecutionId: hookExecId, runId: suiteRunId });
           const hookResult = await runHooks([hook], {
-            ...config.sandboxOptions,
+            ...suiteSandboxOptions,
             secretStore: config.secretStore,
             secretRedactor: config.secretRedactor,
-            envVars: { ...config.sandboxOptions.envVars, ...teardownVars }
+            envVars: { ...suiteSandboxOptions.envVars, ...teardownVars }
           });
           const hr = hookResult.results.get(hook.name);
           await reporter?.onHookEnd?.({
@@ -9192,20 +9716,20 @@ async function runSuite(suite, testEntries, config) {
 }
 
 // src/validation/validate.ts
-var import_promises12 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_node_fs6 = require("fs");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path19 = __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_path14 = require("path");
+var import_promises13 = require("fs/promises");
+var import_node_path16 = require("path");
 var import_yaml4 = require("yaml");
 async function parseHooksFile(filePath) {
   let raw;
   try {
-    raw = await (0, import_promises11.readFile)(filePath, "utf-8");
+    raw = await (0, import_promises13.readFile)(filePath, "utf-8");
   } catch (err) {
     return { hooks: [], errors: [`Failed to read hooks file: ${err.message}`] };
   }
@@ -9222,31 +9746,31 @@ async function parseHooksFile(filePath) {
     );
     return { hooks: [], errors };
   }
-  const dir = (0, import_node_path14.dirname)(filePath);
+  const dir = (0, import_node_path16.dirname)(filePath);
   const hooks = result.data.hooks.map((h) => ({
     ...h,
-    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
+    file: (0, import_node_path16.resolve)(dir, h.file),
+    deps: h.deps.map((d) => (0, import_node_path16.resolve)(dir, d)),
+    packageFile: h.packageFile ? (0, import_node_path16.resolve)(dir, h.packageFile) : void 0
   }));
   return { hooks, errors: [] };
 }
 
 // src/utils/path-validation.ts
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 function isPathInsideDir(childPath, parentDir) {
   if (!childPath) return false;
-  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);
+  const resolved = import_node_path17.default.resolve(parentDir, childPath);
+  const relative2 = import_node_path17.default.relative(parentDir, resolved);
+  return !!relative2 && !relative2.startsWith("..") && !import_node_path17.default.isAbsolute(relative2);
 }
 
 // src/workspace/workspace-paths.ts
 var import_node_fs5 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_glob = require("glob");
 function toForwardSlash(value) {
-  return value.split(import_node_path16.default.sep).join("/");
+  return value.split(import_node_path18.default.sep).join("/");
 }
 function trimLeadingCurrentDir(value) {
   return toForwardSlash(value).replace(/^\.\//, "");
@@ -9265,16 +9789,16 @@ function assertNonEmptyString(value, key) {
 }
 function resolveWorkspaceScalar(configDir, key, configuredPath) {
   const value = assertNonEmptyString(configuredPath, key);
-  const absolutePath = import_node_path16.default.isAbsolute(value) ? import_node_path16.default.resolve(value) : import_node_path16.default.resolve(configDir, value);
+  const absolutePath = import_node_path18.default.isAbsolute(value) ? import_node_path18.default.resolve(value) : import_node_path18.default.resolve(configDir, value);
   return {
     configuredPath: value,
     absolutePath,
-    workspaceRelativePath: trimLeadingCurrentDir(import_node_path16.default.relative(configDir, absolutePath))
+    workspaceRelativePath: trimLeadingCurrentDir(import_node_path18.default.relative(configDir, absolutePath))
   };
 }
 function assertInsideWorkspace(configDir, absolutePath, filePath) {
-  const relativePath = import_node_path16.default.relative(configDir, absolutePath);
-  if (!relativePath || relativePath.startsWith("..") || import_node_path16.default.isAbsolute(relativePath)) {
+  const relativePath = import_node_path18.default.relative(configDir, absolutePath);
+  if (!relativePath || relativePath.startsWith("..") || import_node_path18.default.isAbsolute(relativePath)) {
     throw new Error(`Workspace file path escapes config directory: ${filePath}`);
   }
   return trimLeadingCurrentDir(relativePath);
@@ -9331,8 +9855,8 @@ function isIgnored(workspace, workspaceRelativePath) {
   return workspace.testPathIgnore.length > 0 && matchesAnyPattern(workspaceRelativePath, workspace.testPathIgnore);
 }
 function resolveWorkspacePaths(input) {
-  const configPath = import_node_path16.default.resolve(input.configPath);
-  const configDir = import_node_path16.default.dirname(configPath);
+  const configPath = import_node_path18.default.resolve(input.configPath);
+  const configDir = import_node_path18.default.dirname(configPath);
   const workspace = input.config.workspace;
   if (!workspace) {
     throw new Error("Missing required workspace config key: workspace");
@@ -9370,14 +9894,14 @@ async function discoverWorkspaceFiles(input) {
     absolute: true,
     nodir: true
   });
-  return matches.map((match) => import_node_path16.default.resolve(match)).map((absolutePath) => ({
+  return matches.map((match) => import_node_path18.default.resolve(match)).map((absolutePath) => ({
     kind: input.kind,
     absolutePath,
-    workspaceRelativePath: trimLeadingCurrentDir(import_node_path16.default.relative(input.workspace.configDir, absolutePath))
+    workspaceRelativePath: trimLeadingCurrentDir(import_node_path18.default.relative(input.workspace.configDir, absolutePath))
   })).sort((a, b) => a.workspaceRelativePath.localeCompare(b.workspaceRelativePath));
 }
 async function resolveWorkspaceFileTarget(input) {
-  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 absolutePath = import_node_path18.default.isAbsolute(input.filePath) ? import_node_path18.default.resolve(input.filePath) : import_node_path18.default.resolve(input.workspace.configDir, input.filePath);
   const workspaceRelativePath = assertInsideWorkspace(input.workspace.configDir, absolutePath, input.filePath);
   if (!isWorkspacePathMatch({
     workspace: input.workspace,
@@ -9405,7 +9929,7 @@ async function validateConfig(configPath) {
   const diagnostics = [];
   let content;
   try {
-    content = await (0, import_promises12.readFile)(configPath, "utf-8");
+    content = await (0, import_promises14.readFile)(configPath, "utf-8");
   } catch (err) {
     diagnostics.push({
       file: configPath,
@@ -9507,7 +10031,7 @@ function validateSuiteFile(filePath, content, basedir) {
       });
       continue;
     }
-    const resolved = import_node_path17.default.resolve(basedir, testPath);
+    const resolved = import_node_path19.default.resolve(basedir, testPath);
     if (!(0, import_node_fs6.existsSync)(resolved)) {
       let line = 1;
       let column = 1;
@@ -9529,7 +10053,7 @@ function validateSuiteFile(filePath, content, basedir) {
   return diagnostics;
 }
 function validateFilename(filePath) {
-  const basename3 = import_node_path17.default.basename(filePath);
+  const basename3 = import_node_path19.default.basename(filePath);
   if (!VALID_FILENAME_RE.test(basename3)) {
     return [{
       file: filePath,
@@ -9636,7 +10160,7 @@ async function validateFiles(filePaths, configPath, options = {}) {
     diagnostics.push(...validateFilename(filePath));
     let content;
     try {
-      content = await (0, import_promises12.readFile)(filePath, "utf-8");
+      content = await (0, import_promises14.readFile)(filePath, "utf-8");
     } catch (err) {
       diagnostics.push({
         file: filePath,
@@ -9716,7 +10240,7 @@ async function validateProject(options = {}) {
     }
     filePaths = resolvedFiles;
   } else if (options.files && options.files.length > 0) {
-    filePaths = options.files.map((f) => import_node_path17.default.resolve(f));
+    filePaths = options.files.map((f) => import_node_path19.default.resolve(f));
   } else if (options.workspace) {
     const [testFiles, suiteFiles] = await Promise.all([
       discoverWorkspaceFiles({ workspace: options.workspace, kind: "test" }),
@@ -9763,11 +10287,11 @@ async function validateProject(options = {}) {
     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_path17.default.relative(options.workspace.configDir, filePath).split(import_node_path17.default.sep).join("/") : filePath;
+      const workspaceRelativePath = options.workspace ? import_node_path19.default.relative(options.workspace.configDir, filePath).split(import_node_path19.default.sep).join("/") : filePath;
       const isWorkspaceFile = options.workspace ? isWorkspacePathMatch({ workspace: options.workspace, kind: isSuiteFile(filePath) ? "suite" : "test", workspaceRelativePath }) : true;
       if (!isWorkspaceFile) continue;
       try {
-        const content = await (0, import_promises12.readFile)(filePath, "utf-8");
+        const content = await (0, import_promises14.readFile)(filePath, "utf-8");
         const parsed = (0, import_yaml5.parse)(content);
         if (parsed && typeof parsed === "object") {
           const setup = parsed.setup;
@@ -9864,27 +10388,27 @@ function warnIfOutOfBounds(coords, viewport, actionType) {
 }
 
 // src/hooks/migrate-hook-refs.ts
-var import_promises13 = require("fs/promises");
-var import_node_path18 = require("path");
+var import_promises15 = require("fs/promises");
+var import_node_path20 = require("path");
 var import_yaml6 = require("yaml");
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var import_agent_qa_ids8 = require("@vostride/agent-qa-ids");
 var DEFAULT_CLEANUP_TARGETS = [
   ".agent-qa"
 ];
 var HOOK_INLINE_RE = /\{\{runHook:"([^"]+)"\}\}/g;
-var MigratableHookDefinitionSchema = import_zod20.z.object({
-  id: import_zod20.z.string().optional(),
-  name: import_zod20.z.string().min(1),
-  runtime: import_zod20.z.enum(["node", "bun", "python", "bash"]),
-  file: import_zod20.z.string().min(1),
-  deps: import_zod20.z.array(import_zod20.z.string()).optional(),
-  packageFile: import_zod20.z.string().optional(),
-  timeout: import_zod20.z.string().min(1),
-  network: import_zod20.z.boolean().optional()
+var MigratableHookDefinitionSchema = import_zod21.z.object({
+  id: import_zod21.z.string().optional(),
+  name: import_zod21.z.string().min(1),
+  runtime: import_zod21.z.enum(["node", "bun", "python", "bash"]),
+  file: import_zod21.z.string().min(1),
+  deps: import_zod21.z.array(import_zod21.z.string()).optional(),
+  packageFile: import_zod21.z.string().optional(),
+  timeout: import_zod21.z.string().min(1),
+  network: import_zod21.z.boolean().optional()
 }).strict();
-var MigratableHooksFileSchema = import_zod20.z.object({
-  hooks: import_zod20.z.array(MigratableHookDefinitionSchema).min(1)
+var MigratableHooksFileSchema = import_zod21.z.object({
+  hooks: import_zod21.z.array(MigratableHookDefinitionSchema).min(1)
 }).strict();
 var HookReferenceMigrationError = class extends Error {
   errors;
@@ -9971,8 +10495,8 @@ function rewriteSteps(owner, filePath, hookNameToId, hookIds, errors) {
   return changed;
 }
 async function resolveWorkspaceMigrationContext(workspaceDir, configPath) {
-  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 resolvedConfigPath = configPath ? (0, import_node_path20.resolve)(configPath) : (0, import_node_path20.resolve)(workspaceDir, "agent-qa.config.yaml");
+  const rawConfig = await (0, import_promises15.readFile)(resolvedConfigPath, "utf-8");
   const parsedConfig = (0, import_yaml6.parse)(rawConfig);
   const configResult = AgentQaConfigSchema.safeParse(parsedConfig);
   if (!configResult.success) {
@@ -9998,7 +10522,7 @@ async function resolveWorkspaceMigrationContext(workspaceDir, configPath) {
   };
 }
 async function auditWorkspaceHookReferenceMigration(options) {
-  const workspaceDir = (0, import_node_path18.resolve)(options.workspaceDir);
+  const workspaceDir = (0, import_node_path20.resolve)(options.workspaceDir);
   const errors = [];
   let context;
   try {
@@ -10016,7 +10540,7 @@ async function auditWorkspaceHookReferenceMigration(options) {
   }
   let parsedHooksFile;
   try {
-    parsedHooksFile = (0, import_yaml6.parse)(await (0, import_promises13.readFile)(context.hooksFilePath, "utf-8"));
+    parsedHooksFile = (0, import_yaml6.parse)(await (0, import_promises15.readFile)(context.hooksFilePath, "utf-8"));
   } catch (error) {
     return {
       ok: false,
@@ -10061,15 +10585,15 @@ async function auditWorkspaceHookReferenceMigration(options) {
   const hookIds = new Set(Object.values(hookNameToId));
   if (hooksChanged) {
     rewriteFiles.push({
-      path: (0, import_node_path18.relative)(context.configDir, context.hooksFilePath),
+      path: (0, import_node_path20.relative)(context.configDir, context.hooksFilePath),
       content: (0, import_yaml6.stringify)({ hooks: normalizedHooks })
     });
   }
   for (const relativePath of context.targetFiles) {
-    const absolutePath = (0, import_node_path18.resolve)(context.configDir, relativePath);
+    const absolutePath = (0, import_node_path20.resolve)(context.configDir, relativePath);
     let parsedFile;
     try {
-      parsedFile = (0, import_yaml6.parse)(await (0, import_promises13.readFile)(absolutePath, "utf-8"));
+      parsedFile = (0, import_yaml6.parse)(await (0, import_promises15.readFile)(absolutePath, "utf-8"));
     } catch (error) {
       errors.push(`${relativePath}: ${error.message}`);
       continue;
@@ -10107,14 +10631,14 @@ async function applyWorkspaceHookReferenceMigration(options) {
   if (!audit.ok) {
     throw new HookReferenceMigrationError(audit.errors);
   }
-  const workspaceDir = options.configPath ? (0, import_node_path18.dirname)((0, import_node_path18.resolve)(options.configPath)) : (0, import_node_path18.resolve)(options.workspaceDir);
+  const workspaceDir = options.configPath ? (0, import_node_path20.dirname)((0, import_node_path20.resolve)(options.configPath)) : (0, import_node_path20.resolve)(options.workspaceDir);
   for (const rewrite of audit.rewriteFiles) {
-    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");
+    const outputPath = (0, import_node_path20.resolve)(workspaceDir, rewrite.path);
+    await (0, import_promises15.mkdir)((0, import_node_path20.dirname)(outputPath), { recursive: true });
+    await (0, import_promises15.writeFile)(outputPath, rewrite.content, "utf-8");
   }
   for (const cleanupTarget of audit.cleanupTargets) {
-    await (0, import_promises13.rm)((0, import_node_path18.resolve)(workspaceDir, cleanupTarget), { recursive: true, force: true });
+    await (0, import_promises15.rm)((0, import_node_path20.resolve)(workspaceDir, cleanupTarget), { recursive: true, force: true });
   }
   return audit;
 }
@@ -10183,14 +10707,14 @@ var CircuitBreaker = class {
 var RUN_ARTIFACT_SCHEMA_VERSION = 1;
 
 // src/analytics/identity.ts
-var import_promises17 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_node_os4 = require("os");
-var import_node_path23 = require("path");
+var import_node_path25 = 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_path23.join)(env.XDG_DATA_HOME, "agent-qa", "analytics.json");
-  return (0, import_node_path23.join)(homeDir, ".agent-qa", "analytics.json");
+  if (env.XDG_DATA_HOME) return (0, import_node_path25.join)(env.XDG_DATA_HOME, "agent-qa", "analytics.json");
+  return (0, import_node_path25.join)(homeDir, ".agent-qa", "analytics.json");
 }
 function generateAnalyticsUserId() {
   return (0, import_id_agent.idAgent)({ prefix: "u", words: 10 });
@@ -10206,28 +10730,28 @@ function parseAnalyticsIdentityStore(value) {
     needsMigration: typeof rawIsInternal !== "boolean"
   };
 }
-async function readAnalyticsIdentityStore(path5) {
-  const identityPath = path5 ?? getAnalyticsIdentityPath();
+async function readAnalyticsIdentityStore(path7) {
+  const identityPath = path7 ?? getAnalyticsIdentityPath();
   try {
-    const data = await (0, import_promises17.readFile)(identityPath, "utf-8");
+    const data = await (0, import_promises19.readFile)(identityPath, "utf-8");
     const parsed = JSON.parse(data);
     return parseAnalyticsIdentityStore(parsed);
   } catch {
     return null;
   }
 }
-async function readAnalyticsIdentity(path5) {
-  const parsed = await readAnalyticsIdentityStore(path5);
+async function readAnalyticsIdentity(path7) {
+  const parsed = await readAnalyticsIdentityStore(path7);
   return parsed ? { distinctId: parsed.distinctId, is_internal: parsed.is_internal } : null;
 }
-async function writeAnalyticsIdentity(distinctId, path5, isInternal = false) {
-  const identityPath = path5 ?? getAnalyticsIdentityPath();
-  await (0, import_promises17.mkdir)((0, import_node_path23.dirname)(identityPath), { recursive: true });
-  await (0, import_promises17.writeFile)(identityPath, JSON.stringify({
+async function writeAnalyticsIdentity(distinctId, path7, isInternal = false) {
+  const identityPath = path7 ?? getAnalyticsIdentityPath();
+  await (0, import_promises19.mkdir)((0, import_node_path25.dirname)(identityPath), { recursive: true });
+  await (0, import_promises19.writeFile)(identityPath, JSON.stringify({
     distinctId,
     is_internal: isInternal
   }, null, 2), { mode: 384 });
-  await (0, import_promises17.chmod)(identityPath, 384);
+  await (0, import_promises19.chmod)(identityPath, 384);
 }
 function resolveAnalyticsAgentProduct(env = process.env) {
   if (env.CLAUDECODE !== void 0 || env.CLAUDE_CODE_ENTRYPOINT !== void 0) return "claude_code";
@@ -10436,7 +10960,7 @@ async function flushAnalytics(options) {
 }
 
 // src/analytics/events.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var ANALYTICS_EVENT_NAMES = [
   "agent-qa.analytics.initialized",
   "agent-qa.analytics.test_event",
@@ -10513,34 +11037,34 @@ var ANALYTICS_FAILURE_CATEGORIES = [
   "unknown"
 ];
 var ANALYTICS_SUITE_EXECUTION_MODES = ["sequential", "parallel", "unknown"];
-var AnalyticsEventNameSchema = import_zod21.z.enum(ANALYTICS_EVENT_NAMES);
-var NonNegativeIntegerSchema = import_zod21.z.number().int().min(0);
-var NonNegativeNumberSchema = import_zod21.z.number().min(0);
-var AnalyticsBasePropertiesSchema = import_zod21.z.object({
-  agent_qa_version: import_zod21.z.string().min(1).optional(),
-  surface: import_zod21.z.enum(ANALYTICS_SURFACES).optional(),
-  runtime_context: import_zod21.z.enum(ANALYTICS_RUNTIME_CONTEXTS).optional(),
-  agent_product: import_zod21.z.enum(ANALYTICS_AGENT_PRODUCTS).optional(),
-  transport: import_zod21.z.enum(ANALYTICS_TRANSPORT_KINDS).optional(),
-  privacy_enabled: import_zod21.z.boolean().optional(),
-  posthog_key_present: import_zod21.z.boolean().optional(),
-  $process_person_profile: import_zod21.z.literal(false).optional()
+var AnalyticsEventNameSchema = import_zod22.z.enum(ANALYTICS_EVENT_NAMES);
+var NonNegativeIntegerSchema = import_zod22.z.number().int().min(0);
+var NonNegativeNumberSchema = import_zod22.z.number().min(0);
+var AnalyticsBasePropertiesSchema = import_zod22.z.object({
+  agent_qa_version: import_zod22.z.string().min(1).optional(),
+  surface: import_zod22.z.enum(ANALYTICS_SURFACES).optional(),
+  runtime_context: import_zod22.z.enum(ANALYTICS_RUNTIME_CONTEXTS).optional(),
+  agent_product: import_zod22.z.enum(ANALYTICS_AGENT_PRODUCTS).optional(),
+  transport: import_zod22.z.enum(ANALYTICS_TRANSPORT_KINDS).optional(),
+  privacy_enabled: import_zod22.z.boolean().optional(),
+  posthog_key_present: import_zod22.z.boolean().optional(),
+  $process_person_profile: import_zod22.z.literal(false).optional()
 }).strip();
 var AnalyticsRunPropertiesSchema = AnalyticsBasePropertiesSchema.extend({
-  trigger_source: import_zod21.z.enum(ANALYTICS_TRIGGER_SOURCES).optional(),
-  runner: import_zod21.z.enum(ANALYTICS_RUNNERS).optional(),
-  platform: import_zod21.z.enum(ANALYTICS_PLATFORMS).optional(),
-  status: import_zod21.z.enum(ANALYTICS_RUN_STATUSES).optional(),
+  trigger_source: import_zod22.z.enum(ANALYTICS_TRIGGER_SOURCES).optional(),
+  runner: import_zod22.z.enum(ANALYTICS_RUNNERS).optional(),
+  platform: import_zod22.z.enum(ANALYTICS_PLATFORMS).optional(),
+  status: import_zod22.z.enum(ANALYTICS_RUN_STATUSES).optional(),
   duration_ms: NonNegativeNumberSchema.optional(),
-  run_id: import_zod21.z.string().min(1).optional(),
-  parent_run_id: import_zod21.z.string().min(1).optional(),
-  test_id: import_zod21.z.string().min(1).optional(),
-  suite_id: import_zod21.z.string().min(1).optional(),
-  model_name: import_zod21.z.string().min(1).optional(),
-  provider: import_zod21.z.string().min(1).optional(),
-  provider_mode: import_zod21.z.string().min(1).optional(),
-  planner_model: import_zod21.z.string().min(1).optional(),
-  verifier_model: import_zod21.z.string().min(1).optional(),
+  run_id: import_zod22.z.string().min(1).optional(),
+  parent_run_id: import_zod22.z.string().min(1).optional(),
+  test_id: import_zod22.z.string().min(1).optional(),
+  suite_id: import_zod22.z.string().min(1).optional(),
+  model_name: import_zod22.z.string().min(1).optional(),
+  provider: import_zod22.z.string().min(1).optional(),
+  provider_mode: import_zod22.z.string().min(1).optional(),
+  planner_model: import_zod22.z.string().min(1).optional(),
+  verifier_model: import_zod22.z.string().min(1).optional(),
   input_tokens: NonNegativeIntegerSchema.optional(),
   output_tokens: NonNegativeIntegerSchema.optional(),
   total_tokens: NonNegativeIntegerSchema.optional(),
@@ -10557,16 +11081,16 @@ var AnalyticsRunPropertiesSchema = AnalyticsBasePropertiesSchema.extend({
   hook_count: NonNegativeIntegerSchema.optional(),
   failed_hook_count: NonNegativeIntegerSchema.optional(),
   retry_count: NonNegativeIntegerSchema.optional(),
-  is_flaky: import_zod21.z.boolean().optional(),
-  cancelled: import_zod21.z.boolean().optional(),
-  timed_out: import_zod21.z.boolean().optional(),
-  failure_category: import_zod21.z.enum(ANALYTICS_FAILURE_CATEGORIES).optional(),
-  browser_name: import_zod21.z.string().min(1).optional(),
-  mobile_transport: import_zod21.z.string().min(1).optional(),
-  mobile_provider: import_zod21.z.string().min(1).optional(),
-  app_state: import_zod21.z.string().min(1).optional(),
-  execution_destination: import_zod21.z.string().min(1).optional(),
-  memory_enabled: import_zod21.z.boolean().optional(),
+  is_flaky: import_zod22.z.boolean().optional(),
+  cancelled: import_zod22.z.boolean().optional(),
+  timed_out: import_zod22.z.boolean().optional(),
+  failure_category: import_zod22.z.enum(ANALYTICS_FAILURE_CATEGORIES).optional(),
+  browser_name: import_zod22.z.string().min(1).optional(),
+  mobile_transport: import_zod22.z.string().min(1).optional(),
+  mobile_provider: import_zod22.z.string().min(1).optional(),
+  app_state: import_zod22.z.string().min(1).optional(),
+  execution_destination: import_zod22.z.string().min(1).optional(),
+  memory_enabled: import_zod22.z.boolean().optional(),
   memory_injected_observation_count: NonNegativeIntegerSchema.optional(),
   memory_curator_input_tokens: NonNegativeIntegerSchema.optional(),
   memory_curator_output_tokens: NonNegativeIntegerSchema.optional(),
@@ -10580,33 +11104,33 @@ var AnalyticsRunPropertiesSchema = AnalyticsBasePropertiesSchema.extend({
   suite_passed_count: NonNegativeIntegerSchema.optional(),
   suite_failed_count: NonNegativeIntegerSchema.optional(),
   suite_skipped_count: NonNegativeIntegerSchema.optional(),
-  suite_execution_mode: import_zod21.z.enum(ANALYTICS_SUITE_EXECUTION_MODES).optional(),
+  suite_execution_mode: import_zod22.z.enum(ANALYTICS_SUITE_EXECUTION_MODES).optional(),
   mcp_tool_count: NonNegativeIntegerSchema.optional()
 }).strip();
 var AnalyticsDashboardOpenedPropertiesSchema = AnalyticsBasePropertiesSchema;
 var AnalyticsDashboardLiveModeStartedPropertiesSchema = AnalyticsBasePropertiesSchema.extend({
-  platform: import_zod21.z.enum(ANALYTICS_PLATFORMS).optional(),
-  entity_type: import_zod21.z.enum(["test", "suite", "unknown"]).optional()
+  platform: import_zod22.z.enum(ANALYTICS_PLATFORMS).optional(),
+  entity_type: import_zod22.z.enum(["test", "suite", "unknown"]).optional()
 }).strip();
 var AnalyticsDashboardEntityCreatedPropertiesSchema = AnalyticsBasePropertiesSchema.extend({
-  entity_type: import_zod21.z.enum(["test", "suite", "hook"]).optional(),
-  outcome: import_zod21.z.enum(ANALYTICS_DASHBOARD_OUTCOMES).optional()
+  entity_type: import_zod22.z.enum(["test", "suite", "hook"]).optional(),
+  outcome: import_zod22.z.enum(ANALYTICS_DASHBOARD_OUTCOMES).optional()
 }).strip();
 var AnalyticsMcpServerLifecyclePropertiesSchema = AnalyticsBasePropertiesSchema.extend({
-  mcp_server_state: import_zod21.z.enum(ANALYTICS_MCP_SERVER_STATES).optional(),
-  mcp_transport: import_zod21.z.enum(ANALYTICS_MCP_TRANSPORTS).optional(),
-  mcp_host_kind: import_zod21.z.enum(ANALYTICS_MCP_HOST_KINDS).optional(),
-  mcp_port_kind: import_zod21.z.enum(ANALYTICS_MCP_PORT_KINDS).optional(),
-  mcp_path_kind: import_zod21.z.enum(ANALYTICS_MCP_PATH_KINDS).optional()
+  mcp_server_state: import_zod22.z.enum(ANALYTICS_MCP_SERVER_STATES).optional(),
+  mcp_transport: import_zod22.z.enum(ANALYTICS_MCP_TRANSPORTS).optional(),
+  mcp_host_kind: import_zod22.z.enum(ANALYTICS_MCP_HOST_KINDS).optional(),
+  mcp_port_kind: import_zod22.z.enum(ANALYTICS_MCP_PORT_KINDS).optional(),
+  mcp_path_kind: import_zod22.z.enum(ANALYTICS_MCP_PATH_KINDS).optional()
 }).strip();
 var AnalyticsMcpToolInvokedPropertiesSchema = AnalyticsBasePropertiesSchema.extend({
-  tool_name: import_zod21.z.string().min(1).optional(),
-  mcp_tool_category: import_zod21.z.enum(ANALYTICS_MCP_TOOL_CATEGORIES).optional(),
-  mcp_tool_status: import_zod21.z.enum(ANALYTICS_MCP_TOOL_STATUSES).optional(),
+  tool_name: import_zod22.z.string().min(1).optional(),
+  mcp_tool_category: import_zod22.z.enum(ANALYTICS_MCP_TOOL_CATEGORIES).optional(),
+  mcp_tool_status: import_zod22.z.enum(ANALYTICS_MCP_TOOL_STATUSES).optional(),
   duration_ms: NonNegativeNumberSchema.optional(),
-  mcp_error_category: import_zod21.z.enum(ANALYTICS_MCP_ERROR_CATEGORIES).optional(),
-  mcp_transport: import_zod21.z.enum(ANALYTICS_MCP_TRANSPORTS).optional(),
-  run_id: import_zod21.z.string().min(1).optional()
+  mcp_error_category: import_zod22.z.enum(ANALYTICS_MCP_ERROR_CATEGORIES).optional(),
+  mcp_transport: import_zod22.z.enum(ANALYTICS_MCP_TRANSPORTS).optional(),
+  run_id: import_zod22.z.string().min(1).optional()
 }).strip();
 var AnalyticsEventPropertiesSchemaByName = {
   "agent-qa.analytics.initialized": AnalyticsRunPropertiesSchema,
@@ -10774,7 +11298,7 @@ function formatRunAttributesBlock(attributes) {
 }
 
 // src/analytics/run-reporter.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readString(value) {
@@ -10787,9 +11311,9 @@ function readBoolean(value) {
   return typeof value === "boolean" ? value : void 0;
 }
 function readNestedRecord(source, key) {
-  if (!isRecord(source)) return void 0;
+  if (!isRecord2(source)) return void 0;
   const value = source[key];
-  return isRecord(value) ? value : void 0;
+  return isRecord2(value) ? value : void 0;
 }
 function readAttributes(value) {
   try {
@@ -10833,13 +11357,13 @@ function normalizeSuiteExecutionMode(value) {
   return void 0;
 }
 function readArtifactSource(context) {
-  return isRecord(context?.artifact?.source) ? context?.artifact?.source : void 0;
+  return isRecord2(context?.artifact?.source) ? context?.artifact?.source : void 0;
 }
 function readArtifactConfig(context) {
-  return isRecord(context?.artifact?.config) ? context?.artifact?.config : void 0;
+  return isRecord2(context?.artifact?.config) ? context?.artifact?.config : void 0;
 }
 function readArtifactRuntime(context) {
-  const artifactRuntime = isRecord(context?.artifact?.runtime) ? context?.artifact?.runtime : void 0;
+  const artifactRuntime = isRecord2(context?.artifact?.runtime) ? context?.artifact?.runtime : void 0;
   const configRuntime = readNestedRecord(readArtifactConfig(context), "runtime");
   return {
     ...configRuntime ?? {},
@@ -10947,14 +11471,14 @@ function collectMemoryMetrics(result, state) {
   if (state?.memoryInjectedObservationCount !== void 0) {
     properties.memory_injected_observation_count = state.memoryInjectedObservationCount;
   }
-  if (!isRecord(log)) return properties;
+  if (!isRecord2(log)) return properties;
   properties.memory_enabled = properties.memory_enabled ?? true;
   properties.memory_added_count = readNumber(log.added);
   properties.memory_confirmed_count = readNumber(log.confirmed);
   properties.memory_deprecated_count = readNumber(log.deprecated);
   properties.memory_deleted_count = readNumber(log.deleted);
   properties.memory_error_count = Array.isArray(log.errors) ? log.errors.length : void 0;
-  const tokenUsage = isRecord(log.tokenUsage) ? log.tokenUsage : void 0;
+  const tokenUsage = isRecord2(log.tokenUsage) ? log.tokenUsage : void 0;
   properties.memory_curator_input_tokens = readNumber(tokenUsage?.promptTokens);
   properties.memory_curator_output_tokens = readNumber(tokenUsage?.completionTokens);
   properties.memory_curator_total_tokens = readNumber(tokenUsage?.totalTokens);
@@ -11011,7 +11535,7 @@ var AnalyticsRunReporter = class {
     if (this.disabled) return;
     const runId = context?.runId ?? readString(context?.artifact?.runtime?.runId);
     if (!runId) return;
-    const runtime = isRecord(context?.artifact?.runtime) ? context?.artifact?.runtime : {};
+    const runtime = isRecord2(context?.artifact?.runtime) ? context?.artifact?.runtime : {};
     this.suiteStates.set(runId, {
       runId,
       suiteId: readSuiteId(suite, context),
@@ -11057,7 +11581,7 @@ var AnalyticsRunReporter = class {
   }
   async captureTestResult(result) {
     const state = this.findStateForResult(result);
-    const resultMetadata = isRecord(result.metadata) ? result.metadata : void 0;
+    const resultMetadata = isRecord2(result.metadata) ? result.metadata : void 0;
     const resultRuntime = readNestedRecord(resultMetadata, "runtime");
     const resultAttributes = readAttributes(resultMetadata?.attributes);
     const retryCount = typeof result.retryCount === "number" && result.retryCount >= 0 ? result.retryCount : void 0;
@@ -11137,15 +11661,6 @@ function createAnalyticsRunReporter(options = {}) {
 // src/index.ts
 init_sqlite();
 
-// src/runtime-paths.ts
-var DEFAULT_AGENT_QA_RUNTIME_DIR = ".agent-qa";
-var DEFAULT_AGENT_QA_ARTIFACTS_DIR = ".agent-qa/artifacts";
-var DEFAULT_AGENT_QA_CACHE_DIR = ".agent-qa/cache";
-var DEFAULT_AGENT_QA_SCREENSHOTS_DIR = ".agent-qa/artifacts/screenshots";
-var DEFAULT_AGENT_QA_VIDEOS_DIR = ".agent-qa/artifacts/videos";
-var DEFAULT_AGENT_QA_RUNS_DB_PATH = ".agent-qa/runs.db";
-var LEGACY_AGENT_QA_DASHBOARD_DB_PATH = ".agent-qa/dashboard.db";
-
 // src/screenshot/align.ts
 var import_sharp3 = __toESM(require("sharp"), 1);
 async function alignToWindow(buffer, opts) {
@@ -11199,6 +11714,14 @@ function isMacPlatform() {
   ANDROID_ROLE_MAP,
   ATTR_RUNNER,
   ATTR_TRIGGER,
+  AUTH_STATE_HOOK_CONTAINER_STORAGE_STATE_PATH,
+  AUTH_STATE_HOOK_JSON_ENV,
+  AUTH_STATE_HOOK_STORAGE_STATE_FILENAME,
+  AUTH_STATE_HOOK_STORAGE_STATE_PATH_ENV,
+  AUTH_STATE_HOOK_WORKSPACE_DIR,
+  AUTH_STATE_REDACTION_MARKER,
+  AUTH_STATE_SCHEMA_VERSION,
+  AUTH_STATE_SLUG_PATTERN,
   AccessibilityConfigSchema,
   ActionPlanSchema,
   AdapterLogDataSchema,
@@ -11209,6 +11732,10 @@ function isMacPlatform() {
   AssertionEvaluator,
   AssertionResultSchema,
   AuthPluginDeclarationSchema,
+  AuthStateConfigSchema,
+  AuthStateMetadataSchema,
+  AuthStateNameSchema,
+  AuthStateUseSchema,
   BaseObservationSchema,
   BrowserConfigSchema,
   CACHE_SCHEMA_VERSION,
@@ -11219,6 +11746,7 @@ function isMacPlatform() {
   ConsoleReporter,
   CuratorResponseSchema,
   DEFAULT_AGENT_QA_ARTIFACTS_DIR,
+  DEFAULT_AGENT_QA_AUTH_STATES_DIR,
   DEFAULT_AGENT_QA_CACHE_DIR,
   DEFAULT_AGENT_QA_RUNS_DB_PATH,
   DEFAULT_AGENT_QA_RUNTIME_DIR,
@@ -11289,6 +11817,7 @@ function isMacPlatform() {
   SuiteDefinitionSchema,
   SuiteObservationSchema,
   SuiteTestEntrySchema,
+  TargetNameSchema,
   TargetSchema,
   TestDefinitionSchema,
   TestMetaSchema,
@@ -11307,6 +11836,7 @@ function isMacPlatform() {
   browserstackProvider,
   buildAnalyticsEvent,
   buildAssertionPrompt,
+  buildAuthStateHookEnv,
   buildExtractionPrompt,
   buildInternalRunAttributes,
   buildMemoryIndex,
@@ -11377,7 +11907,9 @@ function isMacPlatform() {
   isBetterSqlite3NodeGypSymlinkConflict,
   isMacPlatform,
   isPathInsideDir,
+  isReservedAuthStateHookEnvKey,
   isWorkspacePathMatch,
+  listAuthStateMetadata,
   listLLMAuthProviderPlugins,
   listObservations,
   listProviders,
@@ -11386,6 +11918,7 @@ function isMacPlatform() {
   mapMobileCapabilities,
   mapWebCapabilities,
   mergeRunAttributes,
+  normalizeAuthStateUse,
   normalizeRole,
   parseAllTests,
   parseEnvFile,
@@ -11399,17 +11932,25 @@ function isMacPlatform() {
   parseTestFile,
   readAnalyticsIdentity,
   readAuth,
+  readAuthStateMetadata,
+  redactAuthStateString,
+  redactAuthStateValue,
   redactSecretValue,
   registerAllProviders,
   registerLLMAuthProviderPlugin,
   registerLLMAuthProviderPlugins,
   registerProvider,
   removeAuth,
+  removeAuthStateFiles,
+  removeAuthStateTarget,
   resetAnalyticsServiceForTests,
   resolveAnalyticsAgentProduct,
   resolveAnalyticsIdentity,
   resolveAnalyticsStandardProperties,
   resolveAppiumExecutable,
+  resolveAuthStateForRun,
+  resolveAuthStatePaths,
+  resolveAuthStateRoot,
   resolveBetterSqliteRebuildCommand,
   resolveFarmCredentials,
   resolveFileReferences,
@@ -11430,6 +11971,7 @@ function isMacPlatform() {
   shouldAblate,
   sortRunAttributesForDisplay,
   stripHookInline,
+  stripReservedAuthStateHookEnv,
   toolCallToActionPlan,
   toolSchemaMiddleware,
   truncateScreenState,
@@ -11444,6 +11986,7 @@ function isMacPlatform() {
   warnIfOutOfBounds,
   writeAnalyticsIdentity,
   writeAuth,
+  writeAuthStateFiles,
   writeObservation
 });
 //# sourceMappingURL=index.cjs.map