@qawolf/cli 1.29.0 → 1.31.0

package/dist/cli.js

@@ -8382,17 +8382,13 @@ function isTimeoutError(err) {
 }
 var missingPackagePattern = /Cannot find (?:package|module) '([^']+)'/;
 var pathLikeSpecifierPattern = /^(?:\.|\/|[A-Za-z]:[\\/])/;
-function extractMissingPackage(text) {
+var sourceFileSpecifierPattern = /\.(?:[cm]?[jt]sx?)$/;
+function extractMissingSpecifier(text) {
   const specifier = missingPackagePattern.exec(text)?.[1];
   if (specifier === undefined || pathLikeSpecifierPattern.test(specifier)) {
     return;
   }
-  return specifier;
-}
-
-// src/core/pluralize.ts
-function pluralize(count, singular, plural = `${singular}s`) {
-  return `${String(count)} ${count === 1 ? singular : plural}`;
+  return sourceFileSpecifierPattern.test(specifier) ? { kind: "path-alias", specifier } : { kind: "package", specifier };
 }
 
 // src/core/formatSeconds.ts
@@ -8400,6 +8396,33 @@ function formatSeconds(ms) {
   return `${Math.round(ms / 1000)}s`;
 }
 
+// src/core/messages/agent.ts
+var followAgain = (sessionId) => `qawolf agent get --follow --session ${sessionId}`;
+var sessionGivenTwice = (argument, flag) => `Two different sessions were named: "${argument}" as an argument and "${flag}" as --session. Pass one of them.`;
+var agentMessages = {
+  answerCancelled: "No answer sent, so QA Wolf is still waiting on one. The session keeps its place: answer it whenever you like.",
+  answerPrompt: "Your answer",
+  answerSendFailed: (reason) => `The answer could not be sent: ${reason}. The session is still waiting, so try again.`,
+  blocked: (sessionId) => `QA Wolf asked a question and cannot continue until it is answered. Answer it with qawolf agent send "<your answer>" --session ${sessionId}.`,
+  detachHint: "Press Ctrl-C to stop following. The session keeps running in the background.",
+  detached: (sessionId) => `Stopped following. The session is still running — pick it back up with ${followAgain(sessionId)}.`,
+  followTimedOut: (sessionId, seconds) => `Stopped following after ${formatSeconds(seconds * 1000)}. The session may still be going: pick it back up with ${followAgain(sessionId)}, or pass --timeout to wait longer.`,
+  noSession: "No session named. Pass --session, set QAWOLF_SESSION_ID, or start one with qawolf agent send.",
+  sessionNotRemembered: (sessionId) => `The session id could not be saved to .qawolf/agent.json, so pass --session ${sessionId} to pick it up later.`,
+  sessionCancelled: (url) => `The session was cancelled before it finished. Read how far it got at ${url}.`,
+  sessionCompleted: "QA Wolf finished the work.",
+  sessionFailed: (url) => `The session failed. Read what happened at ${url}.`,
+  sessionAt: (url) => `Following ${url}`,
+  standing: (status, url) => `${status} — ${url}`,
+  started: (sessionId, url) => `Started session ${sessionId} — ${url}`,
+  waiting: "Waiting for QA Wolf",
+  working: "QA Wolf is working. It reports back here as it goes, which can take a few minutes."
+};
+// src/core/pluralize.ts
+function pluralize(count, singular, plural = `${singular}s`) {
+  return `${String(count)} ${count === 1 ? singular : plural}`;
+}
+
 // src/core/messages/authErrors.ts
 var authErrorMessages = {
   identity: {
@@ -8413,7 +8436,14 @@ var authErrorMessages = {
     rejected401: (noun) => `QA Wolf API rejected the${noun ? ` ${noun}` : ""} request (HTTP 401). Check your API key.`,
     rejected402: (noun) => `QA Wolf API refused the${noun ? ` ${noun}` : ""} request (HTTP 402): billing prevented it.`,
     rejected403: (noun) => `QA Wolf API rejected the${noun ? ` ${noun}` : ""} request (HTTP 403). Check that your API key has access to this environment.`,
-    notFound404: (noun) => `QA Wolf API could not find ${noun ? `${noun} for that environment` : "that environment"} (HTTP 404). Check the --env value.`,
+    notFound404Environment: (noun) => `QA Wolf API could not find ${noun ? `${noun} for that environment` : "that environment"} (HTTP 404). Check the --env value.`,
+    notFound404Runner: (runnerId) => runnerId === undefined ? "That runner is not running (HTTP 404)." : `Runner ${runnerId} is not running (HTTP 404).`,
+    runnerIsGone: "It was never launched, or it has since been terminated or idled out.",
+    launchTheRunner: (runnerId) => runnerId === undefined ? "Launch one with qawolf runner launch --id <id>, or name a running one with --runner." : `Launch it with qawolf runner launch --id ${runnerId}, or send this to a different runner with --runner.`,
+    notFound404Run: (runId) => `QA Wolf has no run ${runId ?? "by that id"} on this team (HTTP 404).`,
+    runIdMayBeRunnerLocal: (runId) => `A run id printed by qawolf runner run belongs to that runner rather than to the platform, so this command cannot resolve it. Read that run with qawolf runner events run-status --run ${runId ?? "<id>"}.`,
+    notFound404Record: (noun, id) => `QA Wolf has no ${noun} ${id} (HTTP 404).`,
+    notFound404: (noun) => noun === undefined ? "QA Wolf found nothing matching the request (HTTP 404)." : `QA Wolf found nothing matching the ${noun} request (HTTP 404).`,
     failedWithStatus: (status, noun) => `QA Wolf API${noun ? ` ${noun}` : ""} request failed (HTTP ${status}).`,
     networkUnreachable: (baseUrl, noun) => `Could not reach the QA Wolf API at ${baseUrl}${noun ? ` to fetch ${noun}` : ""}. Check your network connection and QAWOLF_HOST_URL.`,
     timedOut: (timeoutMs, noun) => `The QA Wolf API${noun ? ` ${noun}` : ""} request timed out after ${formatSeconds(timeoutMs)}. The work may still be finishing on the platform.`,
@@ -8669,7 +8699,7 @@ var flowsMessages = {
     extractingBundle: "Extracting bundle",
     downloadingTeamStorageAssets: "Downloading team-storage assets",
     downloadingTeamStorageAssetsProgress: (current, total) => `Downloading team-storage assets (${String(current)}/${String(total)})`,
-    teamStorageRequiresTeamKey: "Team storage requires a team API key; organization keys are not supported here.",
+    teamStorageRequiresTeam: "Team storage needs a team. Pull an environment to name its team, choose a workspace with 'qawolf auth switch', or use a team API key.",
     summary: (result, assetsAbs) => {
       const flows = pluralize(result.flowCount, "flow");
       const envVars = result.envVarCount === 0 ? "" : ` and ${pluralize(result.envVarCount, "environment variable")}`;
@@ -8844,17 +8874,18 @@ var interactMessages = {
 };
 
 // src/core/messages/interactiveRunner/lifecycle.ts
+var pageAt = (url) => `Its runner page is at ${url}`;
 var noRunnerId = "No runner id. Pass --runner, set QAWOLF_RUNNER_ID, or run qawolf runner launch first.";
 var lifecycleMessages = {
-  alreadyRunning: (id) => `Runner ${id} was already running.`,
+  alreadyRunning: (id, url) => `Runner ${id} was already running. ${pageAt(url)}`,
   defaultNotRemembered: (id) => `Runner ${id} could not be written to .qawolf as this directory's default, so later commands will not find it on their own. Pass --runner ${id}, or set QAWOLF_RUNNER_ID=${id}.`,
   defaultNotForgotten: (id) => `Runner ${id} was terminated, but it could not be removed from .qawolf as this directory's default, so later commands will still be sent to it. Pass --runner, or launch a new runner.`,
   envRunnerIdShadowsLaunch: (launchedId, envId) => `QAWOLF_RUNNER_ID=${envId} is still set, so commands that omit --runner will keep targeting it instead of the runner just launched. Pass --runner ${launchedId} to address this one.`,
   keptAlive: (id) => `Runner ${id} is alive, and its inactivity clock has been reset.`,
   launchFailed: (id, error) => `Launching runner ${id} failed. ${error}`,
   launchLost: (id, error) => `Launching runner ${id} failed. ${error}. The request may still have reached QA Wolf and started a runner, so relaunch the same id with qawolf runner launch --id ${id} to attach to it rather than start a second one, or terminate it with qawolf runner terminate --runner ${id}.`,
-  launched: (id) => `Launched runner ${id}.`,
-  launchedForCommand: (id) => `No runner was given, so launched ${id} for this command. Its browser is fresh: nothing has been run on it and nothing is signed in. It bills until it is terminated or idles out, so terminate it with qawolf runner terminate --runner ${id} when you are done.`,
+  launched: (id, url) => `Launched runner ${id}. ${pageAt(url)}`,
+  launchedForCommand: (id, url) => `No runner was given, so launched ${id} for this command. Its browser is fresh: nothing has been run on it and nothing is signed in. It bills until it is terminated or idles out, so terminate it with qawolf runner terminate --runner ${id} when you are done. ${pageAt(url)}`,
   noRunnerIdForImport: `${noRunnerId} An install also needs a live run to go into, which a runner gets from qawolf runner run.`,
   noRunnerIdForHighlight: `${noRunnerId} Highlighting also needs a live page to draw on, which a runner gets from its first run: run a flow on it with qawolf runner run.`,
   noRunnerIdForInspect: `${noRunnerId} Inspecting also needs a page, which a runner gets from its first run: run a flow on it with qawolf runner run.`,
@@ -8865,7 +8896,14 @@ var lifecycleMessages = {
   terminated: (id) => `Terminated runner ${id}.`,
   runStopped: (id) => `Stopped the run on runner ${id}. The runner is still up, on whatever page the run reached.`,
   nothingToStop: (id) => `Runner ${id} had nothing to stop. The run had already finished, or none had been submitted.`,
-  runnerUnreachable: "The runner could not be reached. It may still be starting, or it may have terminated after inactivity. Retry, or launch it again."
+  runnerUnreachable: "The runner could not be reached. It may still be starting, or it may have terminated after inactivity. Retry, or launch it again.",
+  runnerIdCameFrom: (id, source) => ({
+    environment: `The id ${id} came from QAWOLF_RUNNER_ID.`,
+    flag: `The id ${id} came from --runner.`,
+    given: `The id ${id} is the one this call named.`,
+    launched: `Runner ${id} was launched for this command.`,
+    stored: `The id ${id} came from the runner this directory last launched, recorded in .qawolf.`
+  })[source]
 };
 
 // src/core/messages/interactiveRunner/list.ts
@@ -8964,7 +9002,9 @@ ${dir}`,
   ].join(`
 `),
   outerHopCarriedOver: (names) => `Carried over ${pluralize(names.length, "undeclared package")} from the project node_modules: ${listNames(names)}. Declare them in package.json "dependencies".`,
-  moduleNotFoundHint: (pkg, projectDir) => projectDir === undefined ? `Hint: '${pkg}' could not be resolved. Run from within your flows project so its dependencies can be found.` : `Hint: '${pkg}' could not be resolved. Ensure it is declared in ${projectDir}/package.json "dependencies" and run npm install in that project.`
+  moduleNotFoundHint: (pkg, projectDir) => projectDir === undefined ? `Hint: '${pkg}' could not be resolved. Run from within your flows project so its dependencies can be found.` : `Hint: '${pkg}' could not be resolved. Ensure it is declared in ${projectDir}/package.json "dependencies" and run npm install in that project.`,
+  tsconfigUnparsedNotice: (projectDir) => `Not resolving path aliases: ${projectDir}/tsconfig.json is not valid JSON. Comments and trailing commas are not supported, here or on the platform. Remove them so "compilerOptions.paths" can be read.`,
+  pathAliasNotFoundHint: (specifier, projectDir) => projectDir === undefined ? `Hint: '${specifier}' looks like a tsconfig path alias. Run from within your flows project so its tsconfig.json can be found.` : `Hint: '${specifier}' looks like a tsconfig path alias. Ensure "compilerOptions.paths" in ${projectDir}/tsconfig.json maps it to a file that exists.`
 };
 // src/core/messages/updateCheck.ts
 var updateCheckMessages = {
@@ -9088,7 +9128,8 @@ var exitCodes = {
   network: 4,
   config: 5,
   timeout: 6,
-  payment: 7
+  payment: 7,
+  notFound: 8
 };
 function exit(code, message, proc = process) {
   if (message !== undefined && message.length > 0) {
@@ -9237,8 +9278,10 @@ function resolveHostUrl(env) {
   return configuredHostUrl.replace(/\/+$/, "");
 }
 
-// src/domains/auth/resolve.ts
-import { Entry as Entry5 } from "@napi-rs/keyring";
+// src/shell/keyring.ts
+function loadEntryClass() {
+  return import("@napi-rs/keyring").then((keyring) => keyring.Entry);
+}
 
 // src/core/deviceAuth/tokenExpiry.ts
 function readAccessTokenExpiry(accessToken) {
@@ -11881,6 +11924,56 @@ function handlePipeResult(left, next, ctx) {
   }
   return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
 }
+var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "values", () => def.in._zod.values);
+  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+  inst._zod.parse = (payload, ctx) => {
+    const direction = ctx.direction || "forward";
+    if (direction === "forward") {
+      const left = def.in._zod.run(payload, ctx);
+      if (left instanceof Promise) {
+        return left.then((left) => handleCodecAResult(left, def, ctx));
+      }
+      return handleCodecAResult(left, def, ctx);
+    } else {
+      const right = def.out._zod.run(payload, ctx);
+      if (right instanceof Promise) {
+        return right.then((right) => handleCodecAResult(right, def, ctx));
+      }
+      return handleCodecAResult(right, def, ctx);
+    }
+  };
+});
+function handleCodecAResult(result, def, ctx) {
+  if (result.issues.length) {
+    result.aborted = true;
+    return result;
+  }
+  const direction = ctx.direction || "forward";
+  if (direction === "forward") {
+    const transformed = def.transform(result.value, result);
+    if (transformed instanceof Promise) {
+      return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
+    }
+    return handleCodecTxResult(result, transformed, def.out, ctx);
+  } else {
+    const transformed = def.reverseTransform(result.value, result);
+    if (transformed instanceof Promise) {
+      return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
+    }
+    return handleCodecTxResult(result, transformed, def.in, ctx);
+  }
+}
+function handleCodecTxResult(left, value, nextSchema, ctx) {
+  if (left.issues.length) {
+    left.aborted = true;
+    return left;
+  }
+  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
+}
 var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
@@ -14426,6 +14519,19 @@ function pipe(in_, out) {
     out
   });
 }
+var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
+  ZodPipe.init(inst, def);
+  $ZodCodec.init(inst, def);
+});
+function codec(in_, out, params) {
+  return new ZodCodec({
+    type: "pipe",
+    in: in_,
+    out,
+    transform: params.decode,
+    reverseTransform: params.encode
+  });
+}
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
@@ -14635,7 +14741,6 @@ function resolveWorkosConfig(publishedClientId) {
 
 // src/domains/auth/store/delete.ts
 import { join as join2 } from "node:path";
-import { Entry } from "@napi-rs/keyring";
 
 // src/domains/auth/store/constants.ts
 var service = "qawolf-cli";
@@ -14645,8 +14750,9 @@ var tokensAccount = "oauth-tokens";
 var tokensFile = "tokens.json";
 
 // src/domains/auth/store/delete.ts
-function deleteFromKeychain() {
+async function deleteFromKeychain() {
   try {
+    const Entry = await loadEntryClass();
     new Entry(service, account).deletePassword();
     return "deleted";
   } catch {
@@ -14665,14 +14771,13 @@ async function deleteFromFile(configDir, fs) {
 }
 async function deleteApiKey(configDir, fs) {
   const [keychain, file] = await Promise.all([
-    Promise.resolve(deleteFromKeychain()),
+    deleteFromKeychain(),
     deleteFromFile(configDir, fs)
   ]);
   return { keychain, file };
 }
 // src/domains/auth/store/hasStoredCredentials.ts
 import { join as join3 } from "node:path";
-import { Entry as Entry2 } from "@napi-rs/keyring";
 async function fileExists(path, fs) {
   try {
     await fs.readFile(path);
@@ -14681,9 +14786,10 @@ async function fileExists(path, fs) {
     return !isNoEntError(err);
   }
 }
-function keychainHolds(entryAccount) {
+async function keychainHolds(entryAccount) {
   try {
-    return Boolean(new Entry2(service, entryAccount).getPassword());
+    const Entry = await loadEntryClass();
+    return Boolean(new Entry(service, entryAccount).getPassword());
   } catch {
     return false;
   }
@@ -14693,7 +14799,9 @@ async function hasStoredCredentials(configDir, fs) {
     fileExists(join3(configDir, credentialsFile), fs),
     fileExists(join3(configDir, tokensFile), fs)
   ]);
-  return apiKeyFile || tokenFile || keychainHolds(account) || keychainHolds(tokensAccount);
+  if (apiKeyFile || tokenFile)
+    return true;
+  return await keychainHolds(account) || await keychainHolds(tokensAccount);
 }
 // src/domains/auth/store/load.ts
 import { join as join4 } from "node:path";
@@ -14716,7 +14824,8 @@ var oauthTokensSchema = object({
 async function loadApiKey(configDir, deps) {
   const errors = {};
   try {
-    const entry = new deps.EntryClass(service, account);
+    const Entry = await deps.loadEntryClass();
+    const entry = new Entry(service, account);
     const key = entry.getPassword();
     if (key)
       return { found: true, key, source: "keychain" };
@@ -14737,7 +14846,6 @@ async function loadApiKey(configDir, deps) {
 }
 // src/domains/auth/store/save.ts
 import { join as join5 } from "node:path";
-import { Entry as Entry3 } from "@napi-rs/keyring";
 async function saveToFile(configDir, key, fs) {
   const payload = { apiKey: key };
   await fs.mkdir(configDir, { recursive: true, mode: 448 });
@@ -14745,7 +14853,8 @@ async function saveToFile(configDir, key, fs) {
 }
 async function saveApiKey(configDir, key, fs) {
   try {
-    const entry = new Entry3(service, account);
+    const Entry = await loadEntryClass();
+    const entry = new Entry(service, account);
     entry.setPassword(key);
     return { stored: "keychain" };
   } catch (err) {
@@ -14773,7 +14882,8 @@ function parseTokens(raw) {
 async function loadTokens(configDir, deps) {
   const errors = {};
   try {
-    const raw = new deps.EntryClass(service, tokensAccount).getPassword();
+    const Entry = await deps.loadEntryClass();
+    const raw = new Entry(service, tokensAccount).getPassword();
     if (raw) {
       const tokens = parseTokens(raw);
       if (tokens)
@@ -14798,7 +14908,6 @@ async function loadTokens(configDir, deps) {
 // src/domains/auth/store/saveTokens.ts
 import { randomUUID } from "node:crypto";
 import { join as join7 } from "node:path";
-import { Entry as Entry4 } from "@napi-rs/keyring";
 async function saveToFile2(configDir, tokens, fs) {
   await fs.mkdir(configDir, { recursive: true, mode: 448 });
   const target = join7(configDir, tokensFile);
@@ -14815,11 +14924,13 @@ async function saveToFile2(configDir, tokens, fs) {
 }
 async function saveTokens(configDir, tokens, fs) {
   try {
-    new Entry4(service, tokensAccount).setPassword(JSON.stringify(tokens));
+    const Entry = await loadEntryClass();
+    new Entry(service, tokensAccount).setPassword(JSON.stringify(tokens));
     return { stored: "keychain" };
   } catch (err) {
     try {
-      new Entry4(service, tokensAccount).deletePassword();
+      const Entry = await loadEntryClass();
+      new Entry(service, tokensAccount).deletePassword();
     } catch {}
     await saveToFile2(configDir, tokens, fs);
     return { stored: "file", keychainError: errorMessage(err) };
@@ -14882,7 +14993,7 @@ async function resolveOauthToken(configDir, deps) {
 // src/domains/auth/resolve.ts
 function makeOauthDeps(fs) {
   return {
-    loadTokens: (configDir) => loadTokens(configDir, { EntryClass: Entry5, fs }),
+    loadTokens: (configDir) => loadTokens(configDir, { loadEntryClass, fs }),
     refreshTokens: async ({ refreshToken, organizationId, clientId }) => {
       const config = resolveWorkosConfig(clientId);
       if (!config.configured) {
@@ -14904,7 +15015,7 @@ function makeOauthDeps(fs) {
 }
 function makeDefaultDeps(fs) {
   return {
-    loadApiKey: (configDir) => loadApiKey(configDir, { EntryClass: Entry5, fs }),
+    loadApiKey: (configDir) => loadApiKey(configDir, { loadEntryClass, fs }),
     resolveOauth: (configDir) => resolveOauthToken(configDir, makeOauthDeps(fs)),
     env: process.env
   };
@@ -15017,6 +15128,47 @@ function createLoggingSystem(opts) {
   };
 }
 
+// src/core/publicApi/notFoundSubject.ts
+var runnerRoutesThatNameNoRunner = new Set([
+  "runner.launch",
+  "runner.list"
+]);
+var runRoutesThatResolveOneRun = new Set([
+  "run.diagnose",
+  "run.get",
+  "run.reattempt",
+  "run.stop"
+]);
+var recordFieldNouns = [
+  ["sessionId", "session"],
+  ["triggerId", "trigger"],
+  ["issueId", "issue"],
+  ["flowId", "flow"],
+  ["filePath", "file"]
+];
+function field(input, name) {
+  if (typeof input !== "object" || input === null)
+    return;
+  const value = input[name];
+  return typeof value === "string" ? value : undefined;
+}
+function notFoundSubject(contractName, input) {
+  if (contractName.startsWith("runner.") && !runnerRoutesThatNameNoRunner.has(contractName)) {
+    return { kind: "runner", runnerId: field(input, "id") };
+  }
+  if (runRoutesThatResolveOneRun.has(contractName)) {
+    return { kind: "run", runId: field(input, "runId") };
+  }
+  for (const [name, noun] of recordFieldNouns) {
+    const id = field(input, name);
+    if (id !== undefined)
+      return { id, kind: "record", noun };
+  }
+  if (field(input, "environmentId") !== undefined)
+    return { kind: "environment" };
+  return { kind: "other" };
+}
+
 // src/core/publicApi/flagKind.ts
 function flagKind(schema) {
   if (schema.type === "string")
@@ -15187,6 +15339,42 @@ function applyWorkspaceId(inputSchema, input, workspaceId) {
   return { ...input, workspaceId };
 }
 
+// src/shell/platform/describeNotFound.ts
+var m = authMessages.errors.request;
+var saysNothingMore = (reason) => /^(\w+ )*not ?found\.?$/i.test(reason.trim());
+function describeNotFound(subject, noun, reason) {
+  const explained = reason && !saysNothingMore(reason) ? reason : undefined;
+  const say = (own) => {
+    const body = [explained ? undefined : own.guess, own.guidance].filter((line) => line);
+    return {
+      error: explained ? `${explained} (HTTP 404)` : own.statement,
+      exitCode: exitCodes.notFound,
+      ...body.length > 0 ? { errorBody: body.join(`
+`) } : {}
+    };
+  };
+  switch (subject?.kind) {
+    case "runner":
+      return say({
+        guess: m.runnerIsGone,
+        guidance: m.launchTheRunner(subject.runnerId),
+        statement: m.notFound404Runner(subject.runnerId)
+      });
+    case "run":
+      return say({
+        guess: m.runIdMayBeRunnerLocal(subject.runId),
+        statement: m.notFound404Run(subject.runId)
+      });
+    case "record":
+      return say({ statement: m.notFound404Record(subject.noun, subject.id) });
+    case "other":
+      return say({ statement: m.notFound404(noun) });
+    case "environment":
+    case undefined:
+      return say({ statement: m.notFound404Environment(noun) });
+  }
+}
+
 // src/shell/platform/parseErrorBody.ts
 var defaultMaxLength = 1024;
 function asRecord(value) {
@@ -15229,69 +15417,69 @@ function clip(message, maxLength) {
 }
 
 // src/shell/platform/describeErrors.ts
-var m = authMessages.errors;
+var m2 = authMessages.errors;
 var inlineReasonMaxLength = 200;
 function describeIdentityError(err) {
   if (err.kind === "http") {
     if (err.status === 401 || err.status === 403) {
       return {
-        error: m.identity.invalidOrUnauthorized,
+        error: m2.identity.invalidOrUnauthorized,
         ...err.status === 401 ? { exitCode: exitCodes.auth } : {}
       };
     }
     return {
-      error: m.identity.couldNotVerify(parseErrorBody(err.body, inlineReasonMaxLength), err.status)
+      error: m2.identity.couldNotVerify(parseErrorBody(err.body, inlineReasonMaxLength), err.status)
     };
   }
   if (err.kind === "network") {
-    return { error: m.identity.couldNotVerifyNetwork(err.cause.message) };
+    return { error: m2.identity.couldNotVerifyNetwork(err.cause.message) };
   }
   if (err.kind === "timeout") {
-    return { error: m.identity.timedOut(err.timeoutMs) };
+    return { error: m2.identity.timedOut(err.timeoutMs) };
   }
-  return { error: m.identity.unexpectedFormat };
+  return { error: m2.identity.unexpectedFormat };
 }
-function describeRequestError(err, baseUrl, noun) {
+function describeRequestError(err, baseUrl, noun, notFound) {
   if (err.kind === "http") {
     const reason = parseErrorBody(err.body);
     const body = reason ? { errorBody: reason } : {};
     if (err.status === 401)
       return {
-        error: m.request.rejected401(noun),
+        error: m2.request.rejected401(noun),
         exitCode: exitCodes.auth,
         ...body
       };
     if (err.status === 402)
       return {
-        error: m.request.rejected402(noun),
+        error: m2.request.rejected402(noun),
         exitCode: exitCodes.payment,
         ...body
       };
     if (err.status === 403)
-      return { error: m.request.rejected403(noun), ...body };
+      return { error: m2.request.rejected403(noun), ...body };
     if (err.status === 404)
-      return { error: m.request.notFound404(noun), ...body };
-    return { error: m.request.failedWithStatus(err.status, noun), ...body };
+      return describeNotFound(notFound, noun, reason);
+    return { error: m2.request.failedWithStatus(err.status, noun), ...body };
   }
   if (err.kind === "network") {
-    return { error: m.request.networkUnreachable(baseUrl, noun) };
+    return { error: m2.request.networkUnreachable(baseUrl, noun) };
   }
   if (err.kind === "timeout") {
-    return { error: m.request.timedOut(err.timeoutMs, noun) };
+    return { error: m2.request.timedOut(err.timeoutMs, noun) };
   }
-  return { error: m.request.unexpectedResponse(noun) };
+  return { error: m2.request.unexpectedResponse(noun) };
 }
 function describeBundleDownloadError(err) {
   if (err.kind === "http") {
     if (err.status === 401 || err.status === 403)
-      return m.bundle.linkExpired;
-    return m.bundle.failedWithStatus(err.status);
+      return m2.bundle.linkExpired;
+    return m2.bundle.failedWithStatus(err.status);
   }
   if (err.kind === "network")
-    return m.bundle.networkUnreachable;
+    return m2.bundle.networkUnreachable;
   if (err.kind === "timeout")
-    return m.bundle.timedOut(err.timeoutMs);
-  return m.bundle.malformed;
+    return m2.bundle.timedOut(err.timeoutMs);
+  return m2.bundle.malformed;
 }
 function describeTeamStorageDownloadError(path, err) {
   if (err.kind === "http") {
@@ -15352,12 +15540,16 @@ function callPublicApi(trpc, contract, input, options) {
   return trpc.mutation(path, input, contract.output, options);
 }
 function makeCallPublicApiMethod(trpc, deps, readBackoffMs) {
-  return async (contract, input, options) => requestWithRetry({
-    call: () => callPublicApi(trpc, contract, applyWorkspaceId(contract.input, input, deps.workspaceId), options),
-    backoffMs: contract.kind === "read" ? readBackoffMs : [],
-    describe: (err) => describeRequestError(err, deps.baseUrl, contract.name),
-    sleep: deps.sleep
-  });
+  return async (contract, input, options) => {
+    const sent = applyWorkspaceId(contract.input, input, deps.workspaceId);
+    const subject = notFoundSubject(contract.name, sent);
+    return requestWithRetry({
+      call: () => callPublicApi(trpc, contract, sent, options),
+      backoffMs: contract.kind === "read" ? readBackoffMs : [],
+      describe: (err) => describeRequestError(err, deps.baseUrl, contract.name, subject),
+      sleep: deps.sleep
+    });
+  };
 }
 
 // node_modules/superjson/dist/double-indexed-kv.js
@@ -18988,7 +19180,8 @@ var environmentListItemSchema = object({
   slug: string2()
 });
 var environmentWithVariablesResponseSchema = object({
-  environmentVariables: record(string2(), string2())
+  environmentVariables: record(string2(), string2()),
+  teamId: string2()
 });
 var flowListItemSchema = object({
   flowId: string2(),
@@ -19265,7 +19458,10 @@ async function writeTeamStorageAssets(args, deps) {
 
 // src/shell/platform/teamStorageMethods.ts
 function createTeamStorageMethods(trpc, deps, fs, getIdentity) {
-  async function list() {
+  async function list(opts) {
+    if (opts?.teamId !== undefined) {
+      return listTeamStorageFiles(trpc, { teamId: opts.teamId }, deps);
+    }
     if (deps.workspaceId !== undefined) {
       return listTeamStorageFiles(trpc, { teamId: deps.workspaceId }, deps);
     }
@@ -19275,7 +19471,7 @@ function createTeamStorageMethods(trpc, deps, fs, getIdentity) {
     if (!("team" in identity.value)) {
       return {
         ok: false,
-        error: flowsMessages.pull.teamStorageRequiresTeamKey
+        error: flowsMessages.pull.teamStorageRequiresTeam
       };
     }
     return listTeamStorageFiles(trpc, { teamId: identity.value.team.id }, deps);
@@ -19283,7 +19479,7 @@ function createTeamStorageMethods(trpc, deps, fs, getIdentity) {
   return {
     listTeamStorageFiles: list,
     async syncTeamStorageAssets(assetsAbs, opts) {
-      const files = await list();
+      const files = await list({ teamId: opts?.teamId });
       if (!files.ok)
         return files;
       return downloadTeamStorageAssets({ assetsAbs, files: files.value }, { fetch: deps.fetch, fs, onProgress: opts?.onProgress });
@@ -19313,16 +19509,14 @@ function createPlatformClient(apiKey, deps) {
     ...createTeamStorageMethods(trpc, deps, fs, identityMethods.getIdentity),
     getFlowsBundleUrl: getFlowsBundleUrlImpl,
     callPublicApi: makeCallPublicApiMethod(trpc, deps, requestBackoffMs2),
-    async getEnvVars(envId) {
+    async getEnvironmentWithVariables(envId) {
       const result = await requestWithRetry({
         call: () => trpc.query("environment.getEnvironmentWithVariables", { id: envId }, environmentWithVariablesResponseSchema),
         backoffMs: requestBackoffMs2,
         describe: (err) => describeRequestError(err, deps.baseUrl, "env-vars"),
         sleep: deps.sleep
       });
-      if (!result.ok)
-        return result;
-      return { ok: true, value: result.value.environmentVariables };
+      return result;
     },
     async downloadBundle(envId) {
       const urlResult = await getFlowsBundleUrlImpl(envId);
@@ -20000,7 +20194,7 @@ function p$1(l, e) {
 function g(l, e) {
   return (e.label ?? String(e.value)).toLowerCase().includes(l.toLowerCase());
 }
-function m2(l, e) {
+function m3(l, e) {
   if (e)
     return l ? e : e[0];
 }
@@ -20050,7 +20244,7 @@ var T$1 = class T extends V {
       this.userInput === "\t" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
       return;
     }
-    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m2(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t.name === "tab" || this.isNavigating && t.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
+    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m3(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t.name === "tab" || this.isNavigating && t.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
   }
   deselectAll() {
     this.selectedValues = [];
@@ -20142,6 +20336,30 @@ class a extends V {
     });
   }
 }
+class n extends V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length)
+      return `${this.userInput}█`;
+    const e = t.slice(0, this.cursor), [s, ...r] = t.slice(this.cursor);
+    return `${e}${styleText("inverse", s)}${r.join("")}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t) {
+    super({
+      ...t,
+      initialUserInput: t.initialUserInput ?? t.initialValue
+    }), this.on("userInput", (e) => {
+      this._setValue(e);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
 
 // node_modules/@clack/prompts/dist/index.mjs
 import { styleText as styleText2, stripVTControlCharacters } from "node:util";
@@ -20752,14 +20970,56 @@ ${e.value}` : e.value;
     }
   };
 };
+var text = (t) => new n({
+  validate: t.validate,
+  placeholder: t.placeholder,
+  defaultValue: t.defaultValue,
+  initialValue: t.initialValue,
+  output: t.output,
+  signal: t.signal,
+  input: t.input,
+  render() {
+    const i = t?.withGuide ?? settings.withGuide, s = `${`${i ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${t.message}
+`, c = t.placeholder ? styleText2("inverse", t.placeholder[0]) + styleText2("dim", t.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : c, a = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n = this.error ? `  ${styleText2("yellow", this.error)}` : "", r = i ? `${styleText2("yellow", S_BAR)}  ` : "", d = i ? styleText2("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r}${o}
+${d}${n}
+`;
+      }
+      case "submit": {
+        const n = a ? `  ${styleText2("dim", a)}` : "", r = i ? styleText2("gray", S_BAR) : "";
+        return `${s}${r}${n}`;
+      }
+      case "cancel": {
+        const n = a ? `  ${styleText2(["strikethrough", "dim"], a)}` : "", r = i ? styleText2("gray", S_BAR) : "";
+        return `${s}${r}${n}${a.trim() ? `
+${r}` : ""}`;
+      }
+      default: {
+        const n = i ? `${styleText2("cyan", S_BAR)}  ` : "", r = i ? styleText2("cyan", S_BAR_END) : "";
+        return `${s}${n}${o}
+${r}
+`;
+      }
+    }
+  }
+}).prompt();
 
 // src/shell/ui/clack/theme.ts
+import { styleText as styleText3 } from "node:util";
 var qaWolfBlueBg = "\x1B[48;2;59;59;239m";
 var whiteBold = "\x1B[97;1m";
 var reset = "\x1B[0m";
 function styledTitle(title) {
   return `${qaWolfBlueBg}${whiteBold} ${title} ${reset}`;
 }
+function replySymbol() {
+  return styleText3("cyan", "◇");
+}
 
 // src/shell/ui/clack/styledClack.ts
 function createStyledClack() {
@@ -20770,6 +21030,7 @@ function createStyledClack() {
     cancel,
     confirm,
     password,
+    text,
     autocomplete,
     select,
     isCancel,
@@ -20873,6 +21134,12 @@ function createAgentRenderers() {
     gap: () => writeStderrLine(""),
     stream: (_data, line) => writeStdoutRaw(`${line}
 `),
+    transcript: ({ body, headline }) => writeStdoutRaw(`**${headline}**
+
+${body}
+
+`),
+    wait: () => ({ stop: () => {} }),
     write: (text) => writeStderrRaw(text),
     withProgress: async (steps, done) => {
       const results = [];
@@ -20889,7 +21156,69 @@ function createAgentRenderers() {
   };
 }
 
+// src/core/wrapText.ts
+function wrapLine(rawLine, width) {
+  const line = rawLine.trimEnd();
+  if (line.length <= width)
+    return [line];
+  const indent = /^\s*/.exec(line)?.[0] ?? "";
+  const lines = [];
+  let current = "";
+  for (const word of line.trimStart().split(" ")) {
+    if (current === "") {
+      current = word;
+    } else if (indent.length + current.length + 1 + word.length <= width) {
+      current = `${current} ${word}`;
+    } else {
+      lines.push(indent + current);
+      current = word;
+    }
+  }
+  lines.push(indent + current);
+  return lines;
+}
+function wrapText(text, width) {
+  return text.split(`
+`).flatMap((line) => wrapLine(line, width)).join(`
+`);
+}
+
+// src/shell/ui/renderers/waitLine.ts
+import { styleText as styleText4 } from "node:util";
+var frames = ["◒", "◐", "◓", "◑"];
+var frameMs = 120;
+function elapsed(sinceMs) {
+  const seconds = Math.floor((Date.now() - sinceMs) / 1000);
+  const minutes = Math.floor(seconds / 60);
+  return minutes > 0 ? `[${minutes}m ${seconds % 60}s]` : `[${seconds}s]`;
+}
+function startWaitLine(message, output = process.stdout) {
+  const startedAt = Date.now();
+  let frame = 0;
+  const draw = () => {
+    const mark = styleText4("magenta", frames[frame] ?? "◒");
+    output.write(`\r\x1B[2K${mark}  ${message} ${elapsed(startedAt)}`);
+    frame = (frame + 1) % frames.length;
+  };
+  draw();
+  const timer = setInterval(draw, frameMs);
+  let stopped = false;
+  return {
+    stop: () => {
+      if (stopped)
+        return;
+      stopped = true;
+      clearInterval(timer);
+      output.write("\r\x1B[2K");
+    }
+  };
+}
+
 // src/shell/ui/renderers/modes/human.ts
+function transcriptWidth() {
+  const columns = process.stdout.columns || 80;
+  return Math.min(Math.max(columns - 4, 20), 100);
+}
 function createHumanRenderers(clack, verboseTarget) {
   return {
     intro: (title) => clack.intro(title),
@@ -20911,6 +21240,12 @@ ${body}` : ""));
 `),
     stream: (_data, line) => writeStdoutRaw(`${line}
 `),
+    transcript: ({ body, headline }) => {
+      const lines = wrapText(body, transcriptWidth()).split(`
+`);
+      clack.log.message([headline, ...lines], { symbol: replySymbol() });
+    },
+    wait: (message) => startWaitLine(message),
     write: (text) => writeStdoutRaw(text),
     withProgress: async (steps, done) => {
       const results = [];
@@ -20984,6 +21319,8 @@ function createJsonRenderers() {
     output: (data, _humanMessage) => writeJsonLine(data),
     gap: () => {},
     stream: (data, _line) => writeJsonLine(data),
+    transcript: ({ data }) => writeJsonLine(data),
+    wait: () => ({ stop: () => {} }),
     write: () => {},
     withProgress: async (steps, done) => {
       const results = [];
@@ -21080,6 +21417,20 @@ function createSelect({ mode, clack }) {
   };
 }
 
+// src/shell/ui/renderers/text.ts
+function createText({ mode, clack }) {
+  return async (message) => {
+    assertHumanMode(mode, "text");
+    const value = await clack.text({ message });
+    if (clack.isCancel(value))
+      return { ok: false };
+    const answer = value.trim();
+    if (answer.length === 0)
+      return { ok: false };
+    return { ok: true, value: answer };
+  };
+}
+
 // src/shell/ui/createUi.ts
 function createUI(mode, opts = {}) {
   const clack = opts.clack ?? createStyledClack();
@@ -21089,6 +21440,7 @@ function createUI(mode, opts = {}) {
     confirm: createConfirm({ mode, clack }),
     password: createPassword({ mode, clack }),
     select: createSelect({ mode, clack }),
+    text: createText({ mode, clack }),
     json: createJson()
   };
 }
@@ -21213,7 +21565,7 @@ function startUpdateCheck(deps) {
 // package.json
 var package_default = {
   name: "@qawolf/cli",
-  version: "1.29.0",
+  version: "1.31.0",
   description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   keywords: [
     "automation",
@@ -21288,7 +21640,7 @@ var package_default = {
     "@qawolf/emails": "1.1.1",
     "@qawolf/flow-targets": "1.0.0",
     "@qawolf/flows": "0.1.4",
-    "@qawolf/testkit": "1.1.1",
+    "@qawolf/testkit": "1.2.1",
     commander: "14.0.3",
     "env-paths": "4.0.0",
     picomatch: "4.0.4",
@@ -21429,97 +21781,565 @@ function withAuthContext(signals, fn, deps = {}) {
   };
 }
 
-// src/commands/auth/loginApiKey.ts
-async function loginWithApiKey(ctx) {
-  const result = await ctx.ui.password(authMessages.promptApiKey, "Set QAWOLF_API_KEY to authenticate in non-interactive environments.");
-  if (!result.ok) {
-    ctx.ui.cancel(authMessages.cancelled);
+// src/core/agent/session.ts
+var defaultAgentFollowTimeoutSeconds = 1800;
+var settledStatuses = [
+  "cancelled",
+  "completed",
+  "failed"
+];
+function isSettled(status) {
+  return settledStatuses.includes(status);
+}
+function pendingQuestion(status, replies) {
+  if (status !== "waiting-for-you")
     return;
-  }
-  const apiKey = result.value.trim();
-  if (!apiKey) {
-    ctx.ui.cancel(authMessages.cancelled);
+  return replies[replies.length - 1];
+}
+
+// src/core/agent/formatReply.ts
+var speaker = "QA Wolf";
+function replyTime(askedAt) {
+  const at = new Date(askedAt);
+  if (Number.isNaN(at.getTime()))
+    return;
+  return at.toTimeString().slice(0, 8);
+}
+function replyParts(reply, options) {
+  const time = replyTime(reply.askedAt);
+  const choices = options.listChoices && reply.choices !== undefined ? ["", ...reply.choices.map((choice) => `- ${choice}`)] : [];
+  return {
+    body: [reply.text.trim(), ...choices].join(`
+`),
+    headline: time === undefined ? speaker : `${speaker}  ${time}`
+  };
+}
+
+// src/core/followTimeout.ts
+var followTimeoutSchema = exports_coerce.number().int().positive();
+function parseFollowTimeout(seconds, defaultSeconds) {
+  if (seconds === undefined)
+    return { ok: true, seconds: defaultSeconds };
+  const parsed = followTimeoutSchema.safeParse(seconds);
+  if (!parsed.success)
+    return { error: prettifyError(parsed.error), ok: false };
+  return { ok: true, seconds: parsed.data };
+}
+
+// src/domains/agent/settlement.ts
+function endWithSession(ctx, session) {
+  if (ctx.ui.mode !== "human")
+    ctx.ui.json(session);
+}
+function reportSettlement(ctx, session) {
+  endWithSession(ctx, session);
+  if (session.status === "completed") {
+    ctx.ui.success(agentMessages.sessionCompleted);
     return;
   }
-  await ctx.ui.withProgress([
-    {
-      message: authMessages.verifying,
-      task: async () => {
-        const v = await validateApiKey({
-          platformClient: createPlatformClient(apiKey, {
-            baseUrl: ctx.apiBaseUrl,
-            fetch: globalThis.fetch
-          })
-        });
-        if (!v.valid)
-          throw Error(v.error);
-      }
-    },
-    {
-      message: authMessages.storing,
-      task: async () => saveApiKey(ctx.configDir, apiKey, ctx.fs)
-    }
-  ], ([, saveResult]) => {
-    return saveResult.stored === "file" ? authMessages.storedFile : authMessages.storedKeychain;
-  });
-  ctx.ui.outro(authMessages.outroSuccess);
+  return {
+    error: session.status === "cancelled" ? agentMessages.sessionCancelled(session.url) : agentMessages.sessionFailed(session.url),
+    exitCode: exitCodes.testFailure
+  };
 }
 
-// src/core/deviceAuth/pollState.ts
-var slowDownIncrementMs = 5000;
-var unreachableBackoffFactor = 2;
-function capToLifetime(delayMs, state, nowMs) {
-  return Math.min(delayMs, Math.max(1, state.deadlineMs - nowMs));
+// src/domains/agent/answerQuestion.ts
+async function ask(ctx, question) {
+  const choices = question.choices ?? [];
+  const answer = choices.length > 0 ? await ctx.ui.select(agentMessages.answerPrompt, choices.map((choice) => ({ label: choice, value: choice }))) : await ctx.ui.text(agentMessages.answerPrompt);
+  return answer.ok ? answer.value : undefined;
 }
-function nextPollStep(state, response, nowMs) {
-  if (response.kind === "tokens") {
-    return { action: "done", tokens: response.tokens };
+async function answerQuestion(ctx, options) {
+  const answer = await ask(ctx, options.question);
+  if (answer === undefined) {
+    ctx.ui.warn(agentMessages.answerCancelled);
+    return { type: "declined" };
   }
-  if (nowMs > state.deadlineMs) {
-    return { action: "fail", reason: "timeout", detail: undefined };
+  const sent = await ctx.platformClient.callPublicApi(publicContractsV1.agent.send, {
+    message: answer,
+    sessionId: options.sessionId,
+    ...options.workspaceId === undefined ? {} : { workspaceId: options.workspaceId }
+  });
+  if (!sent.ok) {
+    const failure = failureFields(sent);
+    return {
+      result: {
+        exitCode: exitCodes.network,
+        ...failure,
+        error: agentMessages.answerSendFailed(failure.error)
+      },
+      type: "failed"
+    };
   }
-  switch (response.kind) {
-    case "pending":
-      return {
-        action: "poll",
-        delayMs: capToLifetime(state.intervalMs, state, nowMs),
-        state
-      };
-    case "slow-down": {
-      const slowed = {
-        intervalMs: state.intervalMs + slowDownIncrementMs,
-        deadlineMs: state.deadlineMs
-      };
-      return {
-        action: "poll",
-        delayMs: capToLifetime(slowed.intervalMs, slowed, nowMs),
-        state: slowed
-      };
-    }
-    case "denied":
-      return { action: "fail", reason: "access-denied", detail: undefined };
-    case "expired":
-      return { action: "fail", reason: "expired", detail: undefined };
-    case "unreachable": {
-      const backedOff = {
-        intervalMs: state.intervalMs * unreachableBackoffFactor,
-        deadlineMs: state.deadlineMs
-      };
-      return {
-        action: "poll",
-        delayMs: capToLifetime(backedOff.intervalMs, backedOff, nowMs),
-        state: backedOff
-      };
+  return { repliesAtAnswer: options.repliesSoFar, type: "answered" };
+}
+async function handleQuestion(ctx, options) {
+  const { session, sessionId } = options;
+  if (!options.canPrompt) {
+    ctx.ui.info(agentMessages.blocked(sessionId));
+    endWithSession(ctx, session);
+    return { result: undefined, type: "ended" };
+  }
+  const outcome = await answerQuestion(ctx, {
+    question: options.question,
+    repliesSoFar: session.replies.length,
+    sessionId,
+    workspaceId: options.workspaceId
+  });
+  if (outcome.type === "failed")
+    return { result: outcome.result, type: "ended" };
+  if (outcome.type === "declined")
+    return { result: undefined, type: "ended" };
+  return outcome;
+}
+
+// src/domains/agent/followSession.ts
+var pollIntervalMs = 5000;
+async function followSession(ctx, options, deps) {
+  const { sessionId, workspaceId } = options;
+  const canPrompt = ctx.ui.mode === "human" && ctx.isInteractive;
+  const startedAt = deps.now();
+  let promptedMs = 0;
+  const timedOut = () => deps.now() - startedAt - promptedMs >= options.timeoutSeconds * 1000;
+  let pending = options.initial;
+  let printed = 0;
+  let { repliesAtAnswer } = options;
+  let saidDetachHint = false;
+  let waiting;
+  const stopWaiting = () => {
+    waiting?.stop();
+    waiting = undefined;
+  };
+  const detach = ctx.signals.register(() => {
+    stopWaiting();
+    ctx.ui.info(agentMessages.detached(sessionId));
+  });
+  try {
+    for (let poll = 1;; poll++) {
+      let session;
+      if (pending !== undefined) {
+        session = pending;
+        pending = undefined;
+      } else {
+        const read = await ctx.platformClient.callPublicApi(publicContractsV1.agent.get, { sessionId });
+        if (!read.ok) {
+          return { exitCode: exitCodes.network, ...failureFields(read) };
+        }
+        session = read.value;
+      }
+      const { replies, status } = session;
+      const fresh = replies.slice(printed);
+      printed = replies.length;
+      if (fresh.length > 0)
+        stopWaiting();
+      for (const reply of fresh) {
+        ctx.ui.transcript({
+          ...replyParts(reply, { listChoices: !canPrompt }),
+          data: reply
+        });
+      }
+      if (poll === 1 && replies.length === 0 && !isSettled(status)) {
+        ctx.ui.info(agentMessages.working);
+      }
+      if (isSettled(status)) {
+        stopWaiting();
+        return reportSettlement(ctx, session);
+      }
+      const question = pendingQuestion(status, replies);
+      const awaitingOurAnswer = repliesAtAnswer !== undefined && replies.length <= repliesAtAnswer;
+      if (question !== undefined && !awaitingOurAnswer) {
+        stopWaiting();
+        const promptStartedAt = deps.now();
+        const step = await handleQuestion(ctx, {
+          canPrompt,
+          question,
+          session,
+          sessionId,
+          workspaceId
+        });
+        promptedMs += deps.now() - promptStartedAt;
+        if (step.type === "ended")
+          return step.result;
+        repliesAtAnswer = step.repliesAtAnswer;
+      }
+      if (!saidDetachHint && ctx.ui.mode === "human") {
+        saidDetachHint = true;
+        ctx.ui.info(agentMessages.detachHint);
+      }
+      waiting ??= ctx.ui.wait(agentMessages.waiting);
+      await deps.sleep(pollIntervalMs);
+      if (timedOut()) {
+        return {
+          error: agentMessages.followTimedOut(sessionId, options.timeoutSeconds),
+          exitCode: exitCodes.timeout
+        };
+      }
     }
-    case "error":
-      return { action: "fail", reason: "network", detail: response.detail };
+  } finally {
+    stopWaiting();
+    detach();
   }
 }
 
-// src/domains/auth/deviceLogin.ts
-var cancelled = {
-  ok: false,
-  reason: "cancelled",
+// src/core/resolveId.ts
+async function resolveIdFrom(options) {
+  if (options.given !== undefined) {
+    return { id: options.given, source: "flag" };
+  }
+  const fromEnvironment = options.env[options.environmentVariable]?.trim();
+  if (fromEnvironment) {
+    return { id: fromEnvironment, source: "environment" };
+  }
+  const stored = await options.readStored();
+  return stored === undefined ? undefined : { id: stored, source: "stored" };
+}
+
+// src/domains/agent/resolveSessionId.ts
+var sessionIdEnvironmentVariable = "QAWOLF_SESSION_ID";
+function chooseGivenSessionId(given) {
+  const { argument, flag } = given;
+  if (argument !== undefined && flag !== undefined && argument !== flag) {
+    return { error: sessionGivenTwice(argument, flag), ok: false };
+  }
+  return { ok: true, sessionId: argument ?? flag };
+}
+var resolveSessionId = async (session, deps) => (await resolveIdFrom({
+  env: deps.env,
+  environmentVariable: sessionIdEnvironmentVariable,
+  given: session,
+  readStored: deps.store.readLastSessionId
+}))?.id;
+
+// src/domains/agent/get.ts
+function renderSession(ctx, session) {
+  if (ctx.ui.mode !== "json") {
+    for (const reply of session.replies) {
+      ctx.ui.transcript({
+        ...replyParts(reply, { listChoices: true }),
+        data: reply
+      });
+    }
+  }
+  ctx.ui.output(session, agentMessages.standing(session.status, session.url));
+}
+async function handleAgentGet(ctx, options, deps) {
+  const timeout = parseFollowTimeout(options.timeout, defaultAgentFollowTimeoutSeconds);
+  if (!timeout.ok) {
+    return { error: timeout.error, exitCode: exitCodes.invalidArgs };
+  }
+  const given = chooseGivenSessionId({
+    argument: options.sessionArgument,
+    flag: options.session
+  });
+  if (!given.ok) {
+    return { error: given.error, exitCode: exitCodes.invalidArgs };
+  }
+  const sessionId = await resolveSessionId(given.sessionId, deps);
+  if (sessionId === undefined) {
+    return { error: agentMessages.noSession, exitCode: exitCodes.invalidArgs };
+  }
+  const read = await ctx.platformClient.callPublicApi(publicContractsV1.agent.get, { sessionId });
+  if (!read.ok)
+    return { exitCode: exitCodes.network, ...failureFields(read) };
+  if (!options.follow) {
+    renderSession(ctx, read.value);
+    return;
+  }
+  ctx.ui.info(agentMessages.sessionAt(read.value.url));
+  return followSession(ctx, {
+    initial: read.value,
+    repliesAtAnswer: undefined,
+    sessionId,
+    timeoutSeconds: timeout.seconds,
+    workspaceId: options.workspaceId
+  }, deps);
+}
+
+// src/shell/agent/sessionStore.ts
+import { join as join14 } from "node:path";
+
+// src/core/parseJson.ts
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+
+// src/shell/jsonFile.ts
+var pendingWrites = 0;
+async function readJsonFile(fs, path, schema) {
+  const contents = await fs.readFile(path).catch(() => {
+    return;
+  });
+  if (contents === undefined)
+    return;
+  const parsed = schema.safeParse(parseJson(contents));
+  return parsed.success ? parsed.data : undefined;
+}
+async function writeJsonFileAtomically(fs, path, value) {
+  const pendingPath = `${path}.${String(process.pid)}.${String(++pendingWrites)}.tmp`;
+  try {
+    await fs.writeFile(pendingPath, `${JSON.stringify(value, undefined, 2)}
+`);
+    await fs.rename(pendingPath, path);
+  } finally {
+    await fs.rm(pendingPath, { force: true }).catch(() => {});
+  }
+}
+
+// src/shell/agent/sessionStore.ts
+var storeFileName = "agent.json";
+var storeSchema = object({ lastSessionId: string2().optional() });
+function makeAgentSessionStore(options) {
+  const directory = join14(options.cwd, qawolfDir);
+  const path = join14(directory, storeFileName);
+  return {
+    async readLastSessionId() {
+      const stored = await readJsonFile(options.fs, path, storeSchema);
+      return stored?.lastSessionId;
+    },
+    async rememberSession(sessionId) {
+      await options.fs.mkdir(directory, { recursive: true });
+      await writeJsonFileAtomically(options.fs, path, {
+        lastSessionId: sessionId
+      });
+    }
+  };
+}
+
+// src/domains/agent/deps.ts
+function makeAgentDeps(options) {
+  return {
+    env: options.env,
+    now: Date.now,
+    sleep,
+    store: makeAgentSessionStore({ cwd: options.cwd, fs: options.fs })
+  };
+}
+
+// src/commands/agent/context.ts
+var sessionFlagDescription = `Session to target. Defaults to ${sessionIdEnvironmentVariable}, then the session this directory last started`;
+var timeoutFlagDescription = "Give up following after this long. A session that never settles would otherwise hold a CI job open until the build is killed";
+function agentDeps(ctx) {
+  return makeAgentDeps({
+    cwd: process.cwd(),
+    env: process.env,
+    fs: ctx.fs
+  });
+}
+
+// src/commands/agent/get.register.ts
+var getExamples = `
+Examples:
+  $ qawolf agent get
+  $ qawolf agent get --follow
+  $ qawolf agent get <sessionId> --follow
+  $ qawolf agent get --session <sessionId>`;
+function registerAgentGetCommand(agent, signals) {
+  declareCommandKind(agent.command("get [session]"), "read").description("Read what the QA Wolf AI has said and whether it is still working").option("--follow", "Stay and report what QA Wolf says until the session settles, answering its questions as they come", false).option("--session <id>", sessionFlagDescription).option("--workspace-id <id>", "The workspace an answer given during --follow is sent to. Required when authenticating with an organization or user API key").option("--timeout <seconds>", timeoutFlagDescription, String(defaultAgentFollowTimeoutSeconds)).addHelpText("after", getExamples).action((session, opts, command) => withAuthContext(signals, (ctx) => handleAgentGet(ctx, {
+    follow: opts.follow,
+    session: opts.session,
+    sessionArgument: session,
+    timeout: opts.timeout,
+    workspaceId: opts.workspaceId
+  }, agentDeps(ctx)))(opts, command));
+}
+
+// src/commands/publicApi/environmentOptions.ts
+var environmentIdEnvironmentVariable = "QAWOLF_ENVIRONMENT";
+var optionEnvironmentVariables = new Map([
+  ["environmentId", environmentIdEnvironmentVariable],
+  ["public.run.create.aiTaskId", "QAWOLF_AI_TASK_ID"],
+  ["public.run.create.chatSessionId", "QAWOLF_CHAT_SESSION_ID"]
+]);
+function optionEnvironmentVariable(spec, path) {
+  const dotted = path.join(".");
+  return optionEnvironmentVariables.get(`${spec.trpcPath}.${dotted}`) ?? optionEnvironmentVariables.get(dotted);
+}
+var exclusiveOptions = new Map([
+  ["public.run.create", { keep: "aiTaskId", drop: "chatSessionId" }]
+]);
+function withoutExclusiveConflict(spec, command, options) {
+  const pair = exclusiveOptions.get(spec.trpcPath);
+  if (!pair)
+    return options;
+  if (options[pair.keep] === undefined || options[pair.drop] === undefined) {
+    return options;
+  }
+  const fromEnvironment = (key) => command.getOptionValueSource(key) === "env";
+  if (!fromEnvironment(pair.keep) && !fromEnvironment(pair.drop)) {
+    return options;
+  }
+  const dropped = fromEnvironment(pair.drop) ? pair.drop : pair.keep;
+  return Object.fromEntries(Object.entries(options).filter(([key]) => key !== dropped));
+}
+
+// src/domains/agent/send.ts
+function parseInput(options) {
+  return publicContractsV1.agent.send.input.safeParse({
+    message: options.message,
+    ...options.environmentId === undefined ? {} : { environmentId: options.environmentId },
+    ...options.filePaths === undefined ? {} : { filePaths: options.filePaths },
+    ...options.session === undefined ? {} : { sessionId: options.session },
+    ...options.workspaceId === undefined ? {} : { workspaceId: options.workspaceId }
+  });
+}
+async function handleAgentSend(ctx, options, deps) {
+  const timeout = parseFollowTimeout(options.timeout, defaultAgentFollowTimeoutSeconds);
+  if (!timeout.ok) {
+    return { error: timeout.error, exitCode: exitCodes.invalidArgs };
+  }
+  const input = parseInput(options);
+  if (!input.success) {
+    return {
+      error: prettifyError(input.error),
+      exitCode: exitCodes.invalidArgs
+    };
+  }
+  let repliesAtAnswer;
+  if (options.follow && options.session !== undefined) {
+    const before = await ctx.platformClient.callPublicApi(publicContractsV1.agent.get, { sessionId: options.session });
+    if (before.ok)
+      repliesAtAnswer = before.value.replies.length;
+  }
+  const sent = await ctx.platformClient.callPublicApi(publicContractsV1.agent.send, input.data);
+  if (!sent.ok)
+    return { exitCode: exitCodes.network, ...failureFields(sent) };
+  ctx.ui.output(sent.value, agentMessages.started(sent.value.sessionId, sent.value.url));
+  await deps.store.rememberSession(sent.value.sessionId).catch(() => {
+    ctx.ui.warn(agentMessages.sessionNotRemembered(sent.value.sessionId));
+  });
+  if (!options.follow)
+    return;
+  return followSession(ctx, {
+    initial: undefined,
+    repliesAtAnswer,
+    sessionId: sent.value.sessionId,
+    timeoutSeconds: timeout.seconds,
+    workspaceId: options.workspaceId
+  }, deps);
+}
+
+// src/commands/agent/send.register.ts
+var sendExamples = `
+Examples:
+  $ qawolf agent send "cover the checkout journey"
+  $ qawolf agent send "cover the checkout journey" --follow
+  $ qawolf agent send "use the staging login test@example.com" --session <id>
+  $ qawolf agent send "cover signup" --environment-id staging --follow
+  $ qawolf agent send "cover every journey in the sheet" --file-paths uploads/journeys.csv --follow`;
+function registerAgentSendCommand(agent, signals) {
+  declareCommandKind(agent.command("send <message>"), "write").description("Ask the QA Wolf AI to do a piece of work, such as covering a journey or fixing a broken flow").option("--follow", "Stay and report what QA Wolf says until the session settles, answering its questions as they come", false).option("--session <id>", "Continue this session instead of opening a new one. Send an answer, or add context to work already running").addOption(new Option2("--environment-id <env>", "QA Wolf environment to work in, by id or alias. Ignored with --session, because a session keeps the environment it opened in").env(environmentIdEnvironmentVariable)).option("--workspace-id <id>", "The workspace to work in. Required when authenticating with an organization or user API key").option("--file-paths <path...>", "Team-storage paths of files this request is about, from qawolf file requestUpload. The AI reads them from storage rather than the message, so a plan of hundreds of journeys costs nothing to send. Up to 20").option("--timeout <seconds>", timeoutFlagDescription, String(defaultAgentFollowTimeoutSeconds)).addHelpText("after", sendExamples).action((message, opts, command) => withAuthContext(signals, (ctx) => handleAgentSend(ctx, {
+    environmentId: opts.environmentId,
+    filePaths: opts.filePaths,
+    follow: opts.follow,
+    message,
+    session: opts.session,
+    timeout: opts.timeout,
+    workspaceId: opts.workspaceId
+  }, agentDeps(ctx)))(opts, command));
+}
+
+// src/commands/agent/index.ts
+function registerAgentCommand(program, signals) {
+  const agent = program.command("agent").description("Ask the QA Wolf AI for work and follow what it does");
+  registerAgentSendCommand(agent, signals);
+  registerAgentGetCommand(agent, signals);
+}
+
+// src/commands/auth/loginApiKey.ts
+async function loginWithApiKey(ctx) {
+  const result = await ctx.ui.password(authMessages.promptApiKey, "Set QAWOLF_API_KEY to authenticate in non-interactive environments.");
+  if (!result.ok) {
+    ctx.ui.cancel(authMessages.cancelled);
+    return;
+  }
+  const apiKey = result.value.trim();
+  if (!apiKey) {
+    ctx.ui.cancel(authMessages.cancelled);
+    return;
+  }
+  await ctx.ui.withProgress([
+    {
+      message: authMessages.verifying,
+      task: async () => {
+        const v = await validateApiKey({
+          platformClient: createPlatformClient(apiKey, {
+            baseUrl: ctx.apiBaseUrl,
+            fetch: globalThis.fetch
+          })
+        });
+        if (!v.valid)
+          throw Error(v.error);
+      }
+    },
+    {
+      message: authMessages.storing,
+      task: async () => saveApiKey(ctx.configDir, apiKey, ctx.fs)
+    }
+  ], ([, saveResult]) => {
+    return saveResult.stored === "file" ? authMessages.storedFile : authMessages.storedKeychain;
+  });
+  ctx.ui.outro(authMessages.outroSuccess);
+}
+
+// src/core/deviceAuth/pollState.ts
+var slowDownIncrementMs = 5000;
+var unreachableBackoffFactor = 2;
+function capToLifetime(delayMs, state, nowMs) {
+  return Math.min(delayMs, Math.max(1, state.deadlineMs - nowMs));
+}
+function nextPollStep(state, response, nowMs) {
+  if (response.kind === "tokens") {
+    return { action: "done", tokens: response.tokens };
+  }
+  if (nowMs > state.deadlineMs) {
+    return { action: "fail", reason: "timeout", detail: undefined };
+  }
+  switch (response.kind) {
+    case "pending":
+      return {
+        action: "poll",
+        delayMs: capToLifetime(state.intervalMs, state, nowMs),
+        state
+      };
+    case "slow-down": {
+      const slowed = {
+        intervalMs: state.intervalMs + slowDownIncrementMs,
+        deadlineMs: state.deadlineMs
+      };
+      return {
+        action: "poll",
+        delayMs: capToLifetime(slowed.intervalMs, slowed, nowMs),
+        state: slowed
+      };
+    }
+    case "denied":
+      return { action: "fail", reason: "access-denied", detail: undefined };
+    case "expired":
+      return { action: "fail", reason: "expired", detail: undefined };
+    case "unreachable": {
+      const backedOff = {
+        intervalMs: state.intervalMs * unreachableBackoffFactor,
+        deadlineMs: state.deadlineMs
+      };
+      return {
+        action: "poll",
+        delayMs: capToLifetime(backedOff.intervalMs, backedOff, nowMs),
+        state: backedOff
+      };
+    }
+    case "error":
+      return { action: "fail", reason: "network", detail: response.detail };
+  }
+}
+
+// src/domains/auth/deviceLogin.ts
+var cancelled = {
+  ok: false,
+  reason: "cancelled",
   detail: undefined
 };
 async function deviceLogin(deps) {
@@ -21841,10 +22661,9 @@ async function selectWorkspace(deps) {
 }
 
 // src/domains/auth/store/saveWorkspaceId.ts
-import { Entry as Entry6 } from "@napi-rs/keyring";
 function makeSaveWorkspaceIdDeps(configDir, fs) {
   return {
-    loadTokens: () => loadTokens(configDir, { EntryClass: Entry6, fs }),
+    loadTokens: () => loadTokens(configDir, { loadEntryClass, fs }),
     saveTokens: (session) => saveTokens(configDir, session, fs)
   };
 }
@@ -22050,11 +22869,11 @@ async function handleLogin(ctx, deps = {}) {
 }
 
 // src/domains/auth/store/deleteTokens.ts
-import { join as join14 } from "node:path";
-import { Entry as Entry7 } from "@napi-rs/keyring";
-function deleteFromKeychain2() {
+import { join as join15 } from "node:path";
+async function deleteFromKeychain2() {
   try {
-    new Entry7(service, tokensAccount).deletePassword();
+    const Entry = await loadEntryClass();
+    new Entry(service, tokensAccount).deletePassword();
     return "deleted";
   } catch {
     return "unavailable";
@@ -22062,7 +22881,7 @@ function deleteFromKeychain2() {
 }
 async function deleteFromFile2(configDir, fs) {
   try {
-    await fs.unlink(join14(configDir, tokensFile));
+    await fs.unlink(join15(configDir, tokensFile));
     return "deleted";
   } catch (err) {
     if (isNoEntError(err))
@@ -22072,7 +22891,7 @@ async function deleteFromFile2(configDir, fs) {
 }
 async function deleteTokens(configDir, fs) {
   const [keychain, file] = await Promise.all([
-    Promise.resolve(deleteFromKeychain2()),
+    deleteFromKeychain2(),
     deleteFromFile2(configDir, fs)
   ]);
   return { keychain, file };
@@ -22121,10 +22940,9 @@ async function handleLogout(ctx, deps = {}) {
 }
 
 // src/domains/auth/refreshStoredSession.ts
-import { Entry as Entry8 } from "@napi-rs/keyring";
 function makeDefaultDeps2(fs) {
   return {
-    loadTokens: (configDir) => loadTokens(configDir, { EntryClass: Entry8, fs }),
+    loadTokens: (configDir) => loadTokens(configDir, { loadEntryClass, fs }),
     resolveOauth: (configDir) => resolveOauthToken(configDir, makeOauthDeps(fs))
   };
 }
@@ -22287,8 +23105,863 @@ function registerAuthCommand(program, signals) {
   declareCommandKind(auth.command("whoami"), "read").description("Show authentication status").action(withContext(signals, handleWhoami));
 }
 
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixel2Android14.js
+var androidPixel2Android14Target = {
+  meta: {
+    androidVersion: "34",
+    deviceModel: "Pixel 2"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixel9.js
+var androidPixel9Target = {
+  meta: {
+    androidVersion: "34",
+    deviceModel: "Pixel 9"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixel9Android14.js
+var androidPixel9Android14Target = {
+  meta: {
+    androidVersion: "34",
+    deviceModel: "Pixel 9"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixel9Android15.js
+var androidPixel9Android15Target = {
+  meta: {
+    androidVersion: "35",
+    deviceModel: "Pixel 9"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixel9Android16.js
+var androidPixel9Android16Target = {
+  meta: {
+    androidVersion: "36",
+    deviceModel: "Pixel 9"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixel.js
+var androidPixelTarget = {
+  meta: {
+    androidVersion: "34",
+    deviceModel: "Pixel 2"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidPixelTabletAndroid14.js
+var androidPixelTabletAndroid14Target = {
+  meta: {
+    androidVersion: "34",
+    deviceModel: "Pixel Tablet"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/android/androidTablet.js
+var androidTabletTarget = {
+  meta: {
+    androidVersion: "34",
+    deviceModel: "Pixel Tablet"
+  },
+  platform: "android",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/allowlistedIphone.js
+var allowlistedIphoneTarget = {
+  meta: {
+    deviceModel: "iPhone 15",
+    iosVersion: "26",
+    targetDevices: "Allowlisted Device"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/appleIdEnabledIpad.js
+var appleIdEnabledIpadTarget = {
+  meta: {
+    appleId: true,
+    deviceModel: "iPad 11",
+    iosVersion: "18"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/appleIdEnabledIphone.js
+var appleIdEnabledIphoneTarget = {
+  meta: {
+    appleId: true,
+    deviceModel: "iPhone 15",
+    iosVersion: "26"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/ipad11ios18.js
+var ipad11ios18Target = {
+  meta: {
+    deviceModel: "iPad 11",
+    iosVersion: "18"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/ipad11ios18AppleId.js
+var ipad11ios18AppleIdTarget = {
+  meta: {
+    appleId: true,
+    deviceModel: "iPad 11",
+    iosVersion: "18"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/ipad11ios26.js
+var ipad11ios26Target = {
+  meta: {
+    deviceModel: "iPad 11",
+    iosVersion: "26"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/ipad.js
+var ipadTarget = {
+  meta: {
+    deviceModel: "iPad 11",
+    iosVersion: "18"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone15ios17.js
+var iphone15ios17Target = {
+  meta: {
+    deviceModel: "iPhone 15",
+    iosVersion: "17"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone15ios18.js
+var iphone15ios18Target = {
+  meta: {
+    deviceModel: "iPhone 15",
+    iosVersion: "18"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone15ios26.js
+var iphone15ios26Target = {
+  meta: {
+    deviceModel: "iPhone 15",
+    iosVersion: "26"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone15ios26Allowlisted.js
+var iphone15ios26AllowlistedTarget = {
+  meta: {
+    deviceModel: "iPhone 15",
+    iosVersion: "26",
+    targetDevices: "Allowlisted Device"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone15ios26AppleId.js
+var iphone15ios26AppleIdTarget = {
+  meta: {
+    appleId: true,
+    deviceModel: "iPhone 15",
+    iosVersion: "26"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone15ios26Private.js
+var iphone15ios26PrivateTarget = {
+  meta: {
+    deviceModel: "iPhone 15",
+    iosVersion: "26",
+    targetDevices: "Team Dedicated Device"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/ios/iphone17ios26.js
+var iphone17ios26Target = {
+  meta: {
+    deviceModel: "iPhone 17",
+    iosVersion: "26"
+  },
+  platform: "ios",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/basic.js
+var webBasicTarget = {
+  meta: "legacy",
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/chrome.js
+var webChromeTarget = {
+  meta: {
+    defaultBrowser: {
+      name: "chrome"
+    },
+    gpuEnabled: false
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/chromeWithGpu.js
+var webChromeWithGpuTarget = {
+  meta: {
+    defaultBrowser: {
+      name: "chrome"
+    },
+    gpuEnabled: true
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/electron.js
+var webElectronTarget = {
+  meta: {
+    gpuEnabled: false,
+    kind: "electron"
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/firefox.js
+var webFirefoxTarget = {
+  meta: {
+    defaultBrowser: {
+      name: "firefox"
+    },
+    gpuEnabled: false
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/firefoxWithGpu.js
+var webFirefoxWithGpuTarget = {
+  meta: {
+    defaultBrowser: {
+      name: "firefox"
+    },
+    gpuEnabled: true
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/safari.js
+var webSafariTarget = {
+  meta: {
+    defaultBrowser: {
+      name: "safari"
+    },
+    gpuEnabled: false
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/web/safariWithGpu.js
+var webSafariWithGpuTarget = {
+  meta: {
+    defaultBrowser: {
+      name: "safari"
+    },
+    gpuEnabled: true
+  },
+  platform: "web",
+  schemaVersion: 1
+};
+
+// node_modules/@qawolf/flow-targets/dist/presets/index.js
+var androidPresetLiteralRaw = [
+  "Android - Pixel",
+  "Android - Pixel 2 (Android 14)",
+  "Android - Pixel 9",
+  "Android - Pixel 9 (Android 14)",
+  "Android - Pixel 9 (Android 15)",
+  "Android - Pixel 9 (Android 16)",
+  "Android - Pixel Tablet (Android 14)",
+  "Android - Tablet"
+];
+var androidPresetLiteralSchema = _enum(androidPresetLiteralRaw);
+var iosPresetLiteralRaw = [
+  "iOS - Allowlisted iPhone",
+  "iOS - Apple ID Enabled iPad",
+  "iOS - Apple ID Enabled iPhone",
+  "iOS - iPad",
+  "iOS - iPad 11 (iOS 18)",
+  "iOS - iPad 11 (iOS 18) (Apple ID)",
+  "iOS - iPad 11 (iOS 26)",
+  "iOS - iPhone 15 (iOS 17)",
+  "iOS - iPhone 15 (iOS 18)",
+  "iOS - iPhone 15 (iOS 26)",
+  "iOS - iPhone 15 (iOS 26) (Apple ID)",
+  "iOS - iPhone 15 (iOS 26) (allowlisted)",
+  "iOS - iPhone 15 (iOS 26) (private)",
+  "iOS - iPhone 17 (iOS 26)"
+];
+var iosPresetLiteralSchema = _enum(iosPresetLiteralRaw);
+var webPresetLiteralRaw = [
+  "Basic",
+  "Electron",
+  "Web - Chrome",
+  "Web - Chrome (GPU)",
+  "Web - Firefox",
+  "Web - Firefox (GPU)",
+  "Web - Safari",
+  "Web - Safari (GPU)"
+];
+var webPresetLiteralSchema = _enum(webPresetLiteralRaw);
+var presetLiteralsSchema = union([
+  androidPresetLiteralSchema,
+  iosPresetLiteralSchema,
+  webPresetLiteralSchema
+]);
+var presetTargetMap = {
+  "Android - Pixel": androidPixelTarget,
+  "Android - Pixel 2 (Android 14)": androidPixel2Android14Target,
+  "Android - Pixel 9": androidPixel9Target,
+  "Android - Pixel 9 (Android 14)": androidPixel9Android14Target,
+  "Android - Pixel 9 (Android 15)": androidPixel9Android15Target,
+  "Android - Pixel 9 (Android 16)": androidPixel9Android16Target,
+  "Android - Pixel Tablet (Android 14)": androidPixelTabletAndroid14Target,
+  "Android - Tablet": androidTabletTarget,
+  Basic: webBasicTarget,
+  Electron: webElectronTarget,
+  "iOS - Allowlisted iPhone": allowlistedIphoneTarget,
+  "iOS - Apple ID Enabled iPad": appleIdEnabledIpadTarget,
+  "iOS - Apple ID Enabled iPhone": appleIdEnabledIphoneTarget,
+  "iOS - iPad": ipadTarget,
+  "iOS - iPad 11 (iOS 18)": ipad11ios18Target,
+  "iOS - iPad 11 (iOS 18) (Apple ID)": ipad11ios18AppleIdTarget,
+  "iOS - iPad 11 (iOS 26)": ipad11ios26Target,
+  "iOS - iPhone 15 (iOS 17)": iphone15ios17Target,
+  "iOS - iPhone 15 (iOS 18)": iphone15ios18Target,
+  "iOS - iPhone 15 (iOS 26)": iphone15ios26Target,
+  "iOS - iPhone 15 (iOS 26) (allowlisted)": iphone15ios26AllowlistedTarget,
+  "iOS - iPhone 15 (iOS 26) (Apple ID)": iphone15ios26AppleIdTarget,
+  "iOS - iPhone 15 (iOS 26) (private)": iphone15ios26PrivateTarget,
+  "iOS - iPhone 17 (iOS 26)": iphone17ios26Target,
+  "Web - Chrome": webChromeTarget,
+  "Web - Chrome (GPU)": webChromeWithGpuTarget,
+  "Web - Firefox": webFirefoxTarget,
+  "Web - Firefox (GPU)": webFirefoxWithGpuTarget,
+  "Web - Safari": webSafariTarget,
+  "Web - Safari (GPU)": webSafariWithGpuTarget
+};
+
+// node_modules/@qawolf/flow-targets/dist/schemas/shared/screenDimensions.js
+var screenDimensions = {
+  "iPad 11": { screenHeight: 2360, screenWidth: 1640 },
+  "iPhone 15": { screenHeight: 2556, screenWidth: 1179 },
+  "iPhone 15 Plus": { screenHeight: 2796, screenWidth: 1290 },
+  "iPhone 15 Pro Max": { screenHeight: 2868, screenWidth: 1320 },
+  "iPhone 16 Plus": { screenHeight: 2796, screenWidth: 1290 },
+  "iPhone 17": { screenHeight: 2622, screenWidth: 1206 },
+  "Pixel 2": { screenHeight: 1920, screenWidth: 1080 },
+  "Pixel 9": { screenHeight: 2424, screenWidth: 1080 },
+  "Pixel Tablet": { screenHeight: 1600, screenWidth: 2560 },
+  playwright_default: { screenHeight: 804, screenWidth: 1288 }
+};
+
+// node_modules/@qawolf/flow-targets/dist/schemas/shared/platforms.js
+var platformsSchema = _enum(["web", "android", "ios"]);
+
+// node_modules/@qawolf/flow-targets/dist/schemas/shared/runnerNames.js
+var runnerNamesSchema = _enum([
+  "node20Basic",
+  "classic",
+  "node20GpuWithPlaywright",
+  "node20WithPlaywright",
+  "node20WithAndroid",
+  "node20WithIos"
+]);
+
+// node_modules/@qawolf/flow-targets/dist/schemas/shared/baseSchemas.js
+var baseInputSchema = object({
+  platform: platformsSchema,
+  schemaVersion: int().positive()
+});
+var baseOutputSchema = baseInputSchema.extend({
+  runnerName: runnerNamesSchema
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/android/v1/supportedModelsSchema.js
+var supportedModelsInputSchema = _enum([
+  "Pixel 2",
+  "Pixel Tablet",
+  "Pixel 9"
+]);
+var supportedModelsOutputSchema = _enum([
+  "pixel_2",
+  "pixel_tablet",
+  "pixel_9"
+]);
+var supportedModelsSchema = codec(supportedModelsInputSchema, supportedModelsOutputSchema, {
+  decode(deviceModel) {
+    switch (deviceModel) {
+      case "Pixel 2":
+        return "pixel_2";
+      case "Pixel 9":
+        return "pixel_9";
+      case "Pixel Tablet":
+        return "pixel_tablet";
+      default:
+        throw Error(`Unsupported device model: ${deviceModel}`);
+    }
+  },
+  encode(deviceModel) {
+    switch (deviceModel) {
+      case "pixel_2":
+        return "Pixel 2";
+      case "pixel_9":
+        return "Pixel 9";
+      case "pixel_tablet":
+        return "Pixel Tablet";
+      default:
+        throw Error(`Unsupported device model: ${deviceModel}`);
+    }
+  }
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/android/v1/input.js
+var supportedVersionsSchema = _enum(["34", "35", "36"]);
+var androidMetaInputSchema = discriminatedUnion("deviceModel", [
+  object({
+    androidVersion: supportedVersionsSchema.extract(["34"]),
+    deviceModel: supportedModelsInputSchema.extract(["Pixel 2"])
+  }),
+  object({
+    androidVersion: supportedVersionsSchema.extract(["34"]),
+    deviceModel: supportedModelsInputSchema.extract(["Pixel Tablet"])
+  }),
+  object({
+    androidVersion: supportedVersionsSchema.extract(["34", "35", "36"]),
+    deviceModel: supportedModelsInputSchema.extract(["Pixel 9"])
+  })
+]);
+var androidTargetInputSchema = baseInputSchema.extend({
+  meta: androidMetaInputSchema,
+  platform: platformsSchema.extract(["android"]),
+  schemaVersion: literal(1)
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/android/v1/output.js
+var androidTargetOutputSchema = baseOutputSchema.extend({
+  ...androidTargetInputSchema.shape,
+  meta: object({
+    androidVersion: supportedVersionsSchema,
+    deviceModel: supportedModelsOutputSchema,
+    screenHeight: number2(),
+    screenWidth: number2()
+  }),
+  runnerName: runnerNamesSchema.extract(["node20WithAndroid"])
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/android/v1/index.js
+var androidExecutionTargetSchema = codec(androidTargetInputSchema, androidTargetOutputSchema, {
+  decode(value) {
+    return {
+      ...value,
+      meta: {
+        ...value.meta,
+        deviceModel: supportedModelsSchema.decode(value.meta.deviceModel),
+        ...screenDimensions[value.meta.deviceModel]
+      },
+      runnerName: "node20WithAndroid"
+    };
+  },
+  encode(value) {
+    return androidTargetInputSchema.parse({
+      ...value,
+      meta: {
+        ...value.meta,
+        deviceModel: supportedModelsSchema.encode(value.meta.deviceModel)
+      }
+    });
+  }
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/android/index.js
+var androidExecutionTargetInputSchema = discriminatedUnion("schemaVersion", [androidTargetInputSchema]);
+var androidExecutionTargetOutputSchema = discriminatedUnion("schemaVersion", [androidTargetOutputSchema]);
+var androidExecutionTargetSchema2 = discriminatedUnion("schemaVersion", [androidExecutionTargetSchema]);
+
+// node_modules/@qawolf/flow-targets/dist/schemas/ios/v1/supportedModelsSchema.js
+var supportedModelsInputSchema2 = _enum([
+  "iPhone 15",
+  "iPhone 15 Plus",
+  "iPhone 15 Pro Max",
+  "iPhone 16 Plus",
+  "iPhone 17",
+  "iPad 11"
+]);
+var supportedModelsOutputSchema2 = _enum([
+  "iphone15_4",
+  "iphone15_5",
+  "iphone16_2",
+  "iphone17_4",
+  "iphone18_3",
+  "ipad15_7"
+]);
+var supportedModelsSchema2 = codec(supportedModelsInputSchema2, supportedModelsOutputSchema2, {
+  decode(deviceModel) {
+    switch (deviceModel) {
+      case "iPad 11":
+        return "ipad15_7";
+      case "iPhone 15":
+        return "iphone15_4";
+      case "iPhone 15 Plus":
+        return "iphone15_5";
+      case "iPhone 15 Pro Max":
+        return "iphone16_2";
+      case "iPhone 16 Plus":
+        return "iphone17_4";
+      case "iPhone 17":
+        return "iphone18_3";
+      default:
+        throw Error(`Unsupported device model: ${deviceModel}`);
+    }
+  },
+  encode(value) {
+    switch (value) {
+      case "ipad15_7":
+        return "iPad 11";
+      case "iphone15_4":
+        return "iPhone 15";
+      case "iphone15_5":
+        return "iPhone 15 Plus";
+      case "iphone16_2":
+        return "iPhone 15 Pro Max";
+      case "iphone17_4":
+        return "iPhone 16 Plus";
+      case "iphone18_3":
+        return "iPhone 17";
+      default:
+        throw Error(`Unsupported device model: ${value}`);
+    }
+  }
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/ios/v1/supportedTargetDevicesSchema.js
+var supportedTargetDevicesInputSchema = _enum([
+  "Any Device",
+  "Allowlisted Device",
+  "Team Dedicated Device"
+]);
+var supportedTargetDevicesOutputSchema = _enum([
+  "anyDevice",
+  "allowlistedDevice",
+  "teamDedicatedDevice"
+]);
+var supportedTargetDevicesSchema = codec(supportedTargetDevicesInputSchema, supportedTargetDevicesOutputSchema, {
+  decode(targetDevices) {
+    switch (targetDevices) {
+      case "Allowlisted Device":
+        return "allowlistedDevice";
+      case "Any Device":
+        return "anyDevice";
+      case "Team Dedicated Device":
+        return "teamDedicatedDevice";
+      default:
+        throw Error(`Unsupported target devices: ${targetDevices}`);
+    }
+  },
+  encode(targetDevices) {
+    switch (targetDevices) {
+      case "allowlistedDevice":
+        return "Allowlisted Device";
+      case "anyDevice":
+        return "Any Device";
+      case "teamDedicatedDevice":
+        return "Team Dedicated Device";
+      default:
+        throw Error(`Unsupported target devices: ${targetDevices}`);
+    }
+  }
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/ios/v1/input.js
+var supportedVersionsInputSchema = _enum(["17", "18", "26"]);
+var baseMetaInputSchema = object({
+  appleId: union([email2(), boolean2()]).optional(),
+  deviceUdid: string2().optional(),
+  targetDevices: supportedTargetDevicesInputSchema.default("Any Device")
+});
+var iosMetaInputSchema = discriminatedUnion("deviceModel", [
+  baseMetaInputSchema.extend({
+    deviceModel: supportedModelsInputSchema2.extract(["iPhone 15"]),
+    iosVersion: supportedVersionsInputSchema.extract(["17", "18", "26"])
+  }),
+  baseMetaInputSchema.extend({
+    deviceModel: supportedModelsInputSchema2.extract(["iPhone 15 Plus"]),
+    iosVersion: supportedVersionsInputSchema.extract(["17"])
+  }),
+  baseMetaInputSchema.extend({
+    deviceModel: supportedModelsInputSchema2.extract(["iPhone 15 Pro Max"]),
+    iosVersion: supportedVersionsInputSchema.extract(["17"])
+  }),
+  baseMetaInputSchema.extend({
+    deviceModel: supportedModelsInputSchema2.extract(["iPhone 16 Plus"]),
+    iosVersion: supportedVersionsInputSchema.extract(["26"])
+  }),
+  baseMetaInputSchema.extend({
+    deviceModel: supportedModelsInputSchema2.extract(["iPhone 17"]),
+    iosVersion: supportedVersionsInputSchema.extract(["26"])
+  }),
+  baseMetaInputSchema.extend({
+    deviceModel: supportedModelsInputSchema2.extract(["iPad 11"]),
+    iosVersion: supportedVersionsInputSchema.extract(["18", "26"])
+  })
+]);
+var iosTargetInputSchema = baseInputSchema.extend({
+  meta: iosMetaInputSchema,
+  platform: platformsSchema.extract(["ios"]),
+  schemaVersion: literal(1)
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/ios/v1/output.js
+var iosTargetOutputSchema = baseOutputSchema.extend({
+  ...iosTargetInputSchema.shape,
+  meta: object({
+    appleId: union([email2(), boolean2()]).optional(),
+    deviceModel: supportedModelsOutputSchema2,
+    deviceUdid: string2().optional(),
+    iosVersion: supportedVersionsInputSchema,
+    screenHeight: number2(),
+    screenWidth: number2(),
+    targetDevices: supportedTargetDevicesOutputSchema
+  }),
+  runnerName: runnerNamesSchema.extract(["node20WithIos"])
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/ios/v1/index.js
+var iosExecutionTargetSchema = codec(iosTargetInputSchema, iosTargetOutputSchema, {
+  decode(value) {
+    return {
+      ...value,
+      meta: {
+        ...value.meta,
+        appleId: value.meta.appleId || undefined,
+        deviceModel: supportedModelsSchema2.decode(value.meta.deviceModel),
+        ...screenDimensions[value.meta.deviceModel],
+        targetDevices: supportedTargetDevicesSchema.decode(value.meta.targetDevices)
+      },
+      runnerName: "node20WithIos"
+    };
+  },
+  encode(value) {
+    return iosTargetInputSchema.parse({
+      ...value,
+      meta: {
+        ...value.meta,
+        deviceModel: supportedModelsSchema2.encode(value.meta.deviceModel),
+        targetDevices: supportedTargetDevicesSchema.encode(value.meta.targetDevices)
+      }
+    });
+  }
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/ios/index.js
+var iosExecutionTargetInputSchema = discriminatedUnion("schemaVersion", [iosTargetInputSchema]);
+var iosExecutionTargetOutputSchema = discriminatedUnion("schemaVersion", [iosTargetOutputSchema]);
+var iosExecutionTargetSchema2 = discriminatedUnion("schemaVersion", [
+  iosExecutionTargetSchema
+]);
+
+// node_modules/@qawolf/flow-targets/dist/schemas/web/v1/input.js
+var supportedBrowserNamesSchema = _enum(["chrome", "firefox", "safari"]);
+var defaultScreenDimensions = {
+  height: 804,
+  width: 1288
+};
+var webBrowserInputSchema = object({
+  name: supportedBrowserNamesSchema,
+  screenHeight: int().positive().default(defaultScreenDimensions.height),
+  screenWidth: int().positive().default(defaultScreenDimensions.width)
+});
+var defaultBrowserInfoSchema = object({
+  browser: optional(never()),
+  defaultBrowser: webBrowserInputSchema,
+  gpuEnabled: boolean2(),
+  kind: literal("browser").default("browser")
+});
+var legacyBrowserInfoSchema = object({
+  browser: webBrowserInputSchema,
+  defaultBrowser: optional(never()),
+  gpuEnabled: boolean2(),
+  kind: literal("browser").default("browser")
+});
+var electronInfoSchema = object({
+  browser: optional(never()),
+  defaultBrowser: optional(never()),
+  gpuEnabled: literal(false).default(false),
+  kind: literal("electron")
+});
+var browserInfoSchema = union([
+  defaultBrowserInfoSchema,
+  legacyBrowserInfoSchema
+]);
+var webMetaSchema = union([browserInfoSchema, electronInfoSchema]);
+var webTargetInputSchema = baseInputSchema.extend({
+  meta: union([webMetaSchema, literal("legacy")]),
+  platform: platformsSchema.extract(["web"]),
+  schemaVersion: literal(1)
+});
+function getWebBrowserInfo(meta) {
+  if ("defaultBrowser" in meta && meta.defaultBrowser)
+    return webBrowserInputSchema.parse(meta.defaultBrowser);
+  if ("browser" in meta && meta.browser)
+    return webBrowserInputSchema.parse(meta.browser);
+  throw Error("Expected either defaultBrowser or browser in web meta");
+}
+
+// node_modules/@qawolf/flow-targets/dist/schemas/web/v1/webRunnerNames.js
+var webRunnerNamesSchema = runnerNamesSchema.extract([
+  "node20Basic",
+  "node20WithPlaywright",
+  "node20GpuWithPlaywright"
+]);
+
+// node_modules/@qawolf/flow-targets/dist/schemas/web/v1/output.js
+var webOutputMetaSchema = union([
+  object({
+    defaultBrowser: webBrowserInputSchema,
+    gpuEnabled: boolean2(),
+    kind: literal("browser").default("browser")
+  }),
+  object({
+    browser: webBrowserInputSchema,
+    gpuEnabled: boolean2(),
+    kind: literal("browser").default("browser")
+  }),
+  object({
+    gpuEnabled: literal(false),
+    kind: literal("electron")
+  }),
+  literal("legacy")
+]);
+var webTargetOutputSchema = baseOutputSchema.extend({
+  meta: webOutputMetaSchema,
+  platform: literal("web"),
+  runnerName: webRunnerNamesSchema,
+  schemaVersion: literal(1)
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/web/v1/index.js
+var webExecutionTargetSchema = codec(webTargetInputSchema, webTargetOutputSchema, {
+  decode(value) {
+    const runnerName = value.meta === "legacy" ? "node20Basic" : value.meta.gpuEnabled ? "node20GpuWithPlaywright" : "node20WithPlaywright";
+    let meta;
+    if (value.meta === "legacy")
+      meta = value.meta;
+    else if (value.meta.kind === "electron") {
+      meta = {
+        gpuEnabled: false,
+        kind: "electron"
+      };
+    } else {
+      const browserInfo = getWebBrowserInfo(value.meta);
+      meta = {
+        defaultBrowser: browserInfo,
+        gpuEnabled: value.meta.gpuEnabled,
+        kind: "browser"
+      };
+    }
+    return {
+      ...value,
+      meta,
+      runnerName
+    };
+  },
+  encode(value) {
+    return webTargetInputSchema.parse(value);
+  }
+});
+
+// node_modules/@qawolf/flow-targets/dist/schemas/web/index.js
+var webExecutionTargetInputSchema = discriminatedUnion("schemaVersion", [webTargetInputSchema]);
+var webExecutionTargetOutputSchema = discriminatedUnion("schemaVersion", [webTargetOutputSchema]);
+var webExecutionTargetSchema2 = discriminatedUnion("schemaVersion", [
+  webExecutionTargetSchema
+]);
+
+// node_modules/@qawolf/flow-targets/dist/schemas/index.js
+var executionTargetInputSchema = discriminatedUnion("platform", [
+  androidExecutionTargetInputSchema,
+  iosExecutionTargetInputSchema,
+  webExecutionTargetInputSchema
+]);
+var executionTargetOutputSchema = discriminatedUnion("platform", [
+  androidExecutionTargetOutputSchema,
+  iosExecutionTargetOutputSchema,
+  webExecutionTargetOutputSchema
+]);
+var executionTargetSchema = discriminatedUnion("platform", [
+  androidExecutionTargetSchema2,
+  iosExecutionTargetSchema2,
+  webExecutionTargetSchema2
+]);
+
+// node_modules/@qawolf/flow-targets/dist/parseExecutionTarget.js
+var isPresetLiteral = (input) => presetLiteralsSchema.safeParse(input).success;
+var parseExecutionTarget = (input) => executionTargetSchema.decode(isPresetLiteral(input) ? presetTargetMap[input] : input);
+// node_modules/@qawolf/flow-targets/dist/index.js
+var presetLiteralOrAdHocTargetSchema = union([
+  presetLiteralsSchema,
+  executionTargetInputSchema
+]);
+
 // src/core/androidTargets.ts
-import { parseExecutionTarget } from "@qawolf/flow-targets";
 function makeAvdName(deviceModel, androidVersion) {
   return `qawolf_${deviceModel.toLowerCase().replace(/ /g, "_")}_api${androidVersion}`;
 }
@@ -22333,11 +24006,11 @@ async function* batchMap(items, fn, size) {
 }
 
 // src/core/nodeModulesBins.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function nodeModulesBinCandidates(envDir, name, platform) {
-  const binDir = join15(envDir, "node_modules", ".bin");
+  const binDir = join16(envDir, "node_modules", ".bin");
   const names = platform === "win32" ? [`${name}.cmd`, `${name}.exe`] : [name];
-  return names.map((shim) => join15(binDir, shim));
+  return names.map((shim) => join16(binDir, shim));
 }
 function appiumCliCandidates(envDir, platform) {
   return nodeModulesBinCandidates(envDir, "appium", platform);
@@ -22394,21 +24067,21 @@ async function checkUiautomator2(spawn, appiumBin, platform) {
 }
 
 // src/core/androidBins.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function withExeSuffix(name, platform) {
   return platform === "win32" ? `${name}.exe` : name;
 }
 function emulatorBin(home, platform) {
   const name = withExeSuffix("emulator", platform);
-  return home ? join16(home, "emulator", name) : name;
+  return home ? join17(home, "emulator", name) : name;
 }
 function adbBin(home, platform) {
   const name = withExeSuffix("adb", platform);
-  return home ? join16(home, "platform-tools", name) : name;
+  return home ? join17(home, "platform-tools", name) : name;
 }
 function cmdlineToolsBin(home, name, platform) {
   const file = platform === "win32" ? `${name}.bat` : name;
-  return join16(home, "cmdline-tools", "latest", "bin", file);
+  return join17(home, "cmdline-tools", "latest", "bin", file);
 }
 function sdkManagerBin(home, platform) {
   return cmdlineToolsBin(home, "sdkmanager", platform);
@@ -22705,9 +24378,9 @@ async function checkNpmRegistry(deps) {
 }
 
 // src/core/playwrightCli.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function playwrightCliJsPath(envDir) {
-  return join17(envDir, "node_modules", "playwright", "cli.js");
+  return join18(envDir, "node_modules", "playwright", "cli.js");
 }
 function playwrightCliInvocation(args) {
   return {
@@ -22721,7 +24394,7 @@ function playwrightCliInvocation(args) {
 var flowsVersion = "0.1.4";
 var playwrightVersion = "1.62.0";
 var emailsVersion = "1.1.1";
-var testkitVersion = "1.1.1";
+var testkitVersion = "1.2.1";
 var appiumVersion = "3.6.0";
 var appiumUiautomator2DriverVersion = "8.4.0";
 var expectWebdriverioVersion = "5.6.5";
@@ -22857,11 +24530,11 @@ function renderResults(ui, results) {
 }
 
 // src/domains/flows/ensureDeps.ts
-import { dirname as dirname4, join as join18 } from "node:path";
+import { dirname as dirname4, join as join19 } from "node:path";
 function findEnvDir(flowPath, fs) {
   let dir = dirname4(flowPath);
   while (true) {
-    if (fs.existsSync(join18(dir, "package.json")))
+    if (fs.existsSync(join19(dir, "package.json")))
       return dir;
     const parent = dirname4(dir);
     if (parent === dir)
@@ -22887,7 +24560,7 @@ function resolveProjectDirSafe(files, fs) {
 }
 
 // src/domains/flows/expand.ts
-import { join as join19, resolve as resolve3 } from "node:path";
+import { join as join20, resolve as resolve3 } from "node:path";
 
 // node_modules/tinyglobby/dist/index.mjs
 import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
@@ -23716,7 +25389,6 @@ async function glob(globInput, options) {
 }
 
 // src/core/flowMeta.ts
-import { getWebBrowserInfo, parseExecutionTarget as parseExecutionTarget2 } from "@qawolf/flow-targets";
 import { basename as basename2 } from "node:path";
 
 // src/core/stringLiteral.ts
@@ -23832,7 +25504,7 @@ var browserNameToPlaywright = {
 function classifyTarget(target) {
   let parsed;
   try {
-    parsed = parseExecutionTarget2(target);
+    parsed = parseExecutionTarget(target);
   } catch {
     return { kind: "unrecognized" };
   }
@@ -23876,11 +25548,11 @@ function makePeekFlowMeta(fs) {
   };
 }
 async function resolveGlobRoots(cwd, fs) {
-  const qawolfPath = join19(cwd, ".qawolf");
+  const qawolfPath = join20(cwd, ".qawolf");
   let envDirs = [];
   try {
     const entries = await fs.readdirWithTypes(qawolfPath);
-    envDirs = entries.filter((e) => e.isDirectory()).map((e) => join19(qawolfPath, e.name));
+    envDirs = entries.filter((e) => e.isDirectory()).map((e) => join20(qawolfPath, e.name));
   } catch {}
   return [cwd, ...envDirs];
 }
@@ -23906,11 +25578,11 @@ async function expandPatterns(patterns, cwd, logger, fs) {
 }
 
 // src/domains/runtimeEnv/clearRuntimeEnv.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // src/domains/runtimeEnv/managedEnvDir.ts
 import { createHash } from "node:crypto";
-import { join as join20, resolve as resolve4 } from "node:path";
+import { join as join21, resolve as resolve4 } from "node:path";
 
 // src/domains/runtimeEnv/pinnedPackages.ts
 var pinnedPackages = [
@@ -23941,19 +25613,19 @@ function managedEnvBaseDir() {
   const override = process.env["QAWOLF_RUNTIME_DIR"]?.trim();
   if (override)
     return resolve4(override);
-  return join20(getDataDir(), "runtime");
+  return join21(getDataDir(), "runtime");
 }
 function runStagingRoot() {
   return `${managedEnvBaseDir()}-runs`;
 }
 function managedEnvDir() {
-  return join20(managedEnvBaseDir(), managedEnvHash());
+  return join21(managedEnvBaseDir(), managedEnvHash());
 }
 async function scaffoldManagedEnv(dir, fs) {
   await fs.mkdir(dir, { recursive: true });
   const dependencies = Object.fromEntries(pinnedPackages.map(({ name, version }) => [name, version]));
-  await fs.writeFile(join20(dir, "package.json"), JSON.stringify({ name: "qawolf-runtime", private: true, dependencies }, undefined, 2));
-  await fs.writeFile(join20(dir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
+  await fs.writeFile(join21(dir, "package.json"), JSON.stringify({ name: "qawolf-runtime", private: true, dependencies }, undefined, 2));
+  await fs.writeFile(join21(dir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
 }
 
@@ -23975,14 +25647,14 @@ async function isManagedRuntimeBase(dir, fs) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       return false;
-    if (!await hasRuntimeSentinel(join21(dir, entry.name), fs))
+    if (!await hasRuntimeSentinel(join22(dir, entry.name), fs))
       return false;
   }
   return true;
 }
 async function hasRuntimeSentinel(hashDir, fs) {
   try {
-    const pkg = JSON.parse(await fs.readFile(join21(hashDir, "package.json")));
+    const pkg = JSON.parse(await fs.readFile(join22(hashDir, "package.json")));
     return pkg.name === runtimeSentinel;
   } catch {
     return false;
@@ -24008,10 +25680,10 @@ function spawnNpmInstall(cwd, spawn2 = spawn) {
 }
 
 // src/domains/runtimeEnv/resolvePinned.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function readInstalledVersion(dir, pkgName, fs) {
   try {
-    const pkgPath = join22(dir, "node_modules", ...pkgName.split("/"), "package.json");
+    const pkgPath = join23(dir, "node_modules", ...pkgName.split("/"), "package.json");
     const raw = JSON.parse(fs.readFileSync(pkgPath));
     const { version } = raw;
     return typeof version === "string" ? version : undefined;
@@ -24059,10 +25731,10 @@ function allPinnedResolved(dir, fs, platform) {
 }
 
 // src/domains/runtimeEnv/shimDeps.ts
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 
 // src/shell/resolveExport.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function pickPath(entry, preference) {
   if (typeof entry === "string")
     return entry;
@@ -24094,28 +25766,28 @@ function resolveFromEnvDir(envDir, specifier, preference = "esm", fs = makeDefau
   const pkgName = parts.slice(0, pkgPartCount).join("/");
   const rest = parts.slice(pkgPartCount);
   const subpath = rest.length > 0 ? "./" + rest.join("/") : ".";
-  const pkgDir = join23(envDir, "node_modules", ...pkgName.split("/"));
+  const pkgDir = join24(envDir, "node_modules", ...pkgName.split("/"));
   let pkg;
   try {
-    pkg = JSON.parse(fs.readFileSync(join23(pkgDir, "package.json")));
+    pkg = JSON.parse(fs.readFileSync(join24(pkgDir, "package.json")));
   } catch (err) {
     if (isNoEntError(err))
-      throw new Error(`Package '${pkgName}' not found in ${join23(envDir, "node_modules")}`, { cause: err });
+      throw new Error(`Package '${pkgName}' not found in ${join24(envDir, "node_modules")}`, { cause: err });
     throw err;
   }
   const exportsMap = normalizeExports(pkg.exports);
   const entry = exportsMap?.[subpath];
   const relative = pickPath(entry, preference) ?? (subpath === "." ? pkg.module ?? pkg.main : undefined);
   if (!relative) {
-    throw new Error(`No entry for "${subpath}" in exports of ${join23(pkgDir, "package.json")}`);
+    throw new Error(`No entry for "${subpath}" in exports of ${join24(pkgDir, "package.json")}`);
   }
-  return join23(pkgDir, relative);
+  return join24(pkgDir, relative);
 }
 
 // src/domains/runtimeEnv/shimDeps.ts
 function readShimMarker(shimDir, fs) {
   try {
-    const pkg = JSON.parse(fs.readFileSync(join24(shimDir, "package.json")));
+    const pkg = JSON.parse(fs.readFileSync(join25(shimDir, "package.json")));
     if (pkg._qawolf_format) {
       return {
         _qawolf_version: pkg._qawolf_version ?? "",
@@ -24131,11 +25803,11 @@ function resolveBunBuild(bunBuild) {
   return bunBuild === false ? undefined : { build: bunBuild };
 }
 async function removeStaleShims(flowsDir, flowsDeps, fs) {
-  const shimsDir = join24(flowsDir, "node_modules");
+  const shimsDir = join25(flowsDir, "node_modules");
   if (!fs.existsSync(shimsDir))
     return;
   for (const dep of flowsDeps) {
-    const shimDepDir = join24(shimsDir, ...dep.split("/"));
+    const shimDepDir = join25(shimsDir, ...dep.split("/"));
     if (readShimMarker(shimDepDir, fs)) {
       await fs.rm(shimDepDir, { recursive: true, force: true });
     }
@@ -24144,17 +25816,17 @@ async function removeStaleShims(flowsDir, flowsDeps, fs) {
 async function buildDepShim(args) {
   const { envDir, flowsDir, dep, fs, build } = args;
   const depParts = dep.split("/");
-  const depDir = join24(envDir, "node_modules", ...depParts);
+  const depDir = join25(envDir, "node_modules", ...depParts);
   if (!fs.existsSync(depDir))
     return;
   let depVersion;
   try {
-    const pkg = JSON.parse(fs.readFileSync(join24(depDir, "package.json")));
+    const pkg = JSON.parse(fs.readFileSync(join25(depDir, "package.json")));
     depVersion = pkg.version ?? "unknown";
   } catch {
     depVersion = "unknown";
   }
-  const shimDir = join24(flowsDir, "node_modules", ...depParts);
+  const shimDir = join25(flowsDir, "node_modules", ...depParts);
   if (fs.existsSync(shimDir)) {
     const marker = readShimMarker(shimDir, fs);
     if (!marker)
@@ -24181,20 +25853,20 @@ async function buildDepShim(args) {
   }
   const shimCode = await output.text();
   await fs.mkdir(shimDir, { recursive: true });
-  await fs.writeFile(join24(shimDir, "package.json"), JSON.stringify({
+  await fs.writeFile(join25(shimDir, "package.json"), JSON.stringify({
     name: dep,
     _qawolf_version: depVersion,
     _qawolf_format: "bun-build-v1"
   }));
-  await fs.writeFile(join24(shimDir, "index.js"), shimCode);
+  await fs.writeFile(join25(shimDir, "index.js"), shimCode);
 }
 async function shimFlowsDeps(envDir, fs = makeDefaultFs(), bunBuild) {
-  const flowsDir = join24(envDir, "node_modules", "@qawolf", "flows");
+  const flowsDir = join25(envDir, "node_modules", "@qawolf", "flows");
   if (!fs.existsSync(flowsDir))
     return;
   let flowsDeps;
   try {
-    const flowsPkg = JSON.parse(fs.readFileSync(join24(flowsDir, "package.json")));
+    const flowsPkg = JSON.parse(fs.readFileSync(join25(flowsDir, "package.json")));
     flowsDeps = Object.keys(flowsPkg.dependencies ?? {});
   } catch {
     return;
@@ -24375,11 +26047,11 @@ function collectValue(value, previous) {
 }
 
 // src/shell/manifest/pulledEnv.ts
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 
 // src/shell/manifest/io.ts
 import { createHash as createHash2 } from "node:crypto";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 var manifestFilename = ".manifest.json";
 var flowEntrySchema = object({
   path: string2(),
@@ -24401,7 +26073,7 @@ var manifestSchema = object({
 async function readManifest(envDir, fs = makeDefaultFs()) {
   let raw;
   try {
-    raw = await fs.readFile(join25(envDir, manifestFilename));
+    raw = await fs.readFile(join26(envDir, manifestFilename));
   } catch (err) {
     if (isNoEntError(err))
       return "missing";
@@ -24435,7 +26107,7 @@ async function readManifest(envDir, fs = makeDefaultFs()) {
 }
 async function writeManifest(envDir, manifest, fs = makeDefaultFs()) {
   const body = JSON.stringify(manifest, undefined, 2);
-  await fs.writeFile(join25(envDir, manifestFilename), `${body}
+  await fs.writeFile(join26(envDir, manifestFilename), `${body}
 `);
 }
 function hashFile(absPath, fs = makeDefaultFs()) {
@@ -24461,7 +26133,7 @@ async function findPulledEnv(ref, cwd, fs = makeDefaultFs()) {
   return;
 }
 async function listPulledEnvDirs(cwd, fs = makeDefaultFs()) {
-  const root = join26(cwd, ".qawolf");
+  const root = join27(cwd, ".qawolf");
   let entries;
   try {
     entries = await fs.readdirWithTypes(root);
@@ -24474,7 +26146,7 @@ async function listPulledEnvDirs(cwd, fs = makeDefaultFs()) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const envDir = join26(root, entry.name);
+    const envDir = join27(root, entry.name);
     const manifest = await readManifest(envDir, fs);
     if (typeof manifest === "string")
       continue;
@@ -24866,7 +26538,7 @@ async function flowsListRemote(ctx, pattern, options) {
 }
 
 // src/domains/flows/pull/handler.ts
-import { dirname as dirname8, join as join31, resolve as resolve8 } from "node:path";
+import { dirname as dirname8, join as join32, resolve as resolve8 } from "node:path";
 
 // src/domains/flows/pull/fetchPhase.ts
 async function fetchTags(ctx, envId) {
@@ -24888,6 +26560,7 @@ async function fetchBundleAndEnvVars(ctx, envId) {
   let bundleFetchedAt;
   let envVars;
   let envVarsFetchedAt;
+  let teamId;
   let tags;
   await ctx.ui.withProgress([
     {
@@ -24903,10 +26576,11 @@ async function fetchBundleAndEnvVars(ctx, envId) {
     {
       message: flowsMessages.pull.fetchingEnvVars,
       task: async () => {
-        const result = await platformClient.getEnvVars(envId);
+        const result = await platformClient.getEnvironmentWithVariables(envId);
         if (!result.ok)
           throw new Error(result.error);
-        envVars = result.value;
+        envVars = result.value.environmentVariables;
+        teamId = result.value.teamId;
         envVarsFetchedAt = new Date;
       }
     },
@@ -24917,10 +26591,17 @@ async function fetchBundleAndEnvVars(ctx, envId) {
       }
     }
   ], flowsMessages.pull.downloadComplete);
-  if (tmpArchive === undefined || bundleFetchedAt === undefined || envVars === undefined || envVarsFetchedAt === undefined) {
+  if (tmpArchive === undefined || bundleFetchedAt === undefined || envVars === undefined || envVarsFetchedAt === undefined || teamId === undefined) {
     throw new Error("Unexpected state: the bundle and env vars were not fetched. " + "This is a bug - please report it at https://github.com/qawolf/cli/issues");
   }
-  return { tmpArchive, bundleFetchedAt, envVars, envVarsFetchedAt, tags };
+  return {
+    tmpArchive,
+    bundleFetchedAt,
+    envVars,
+    envVarsFetchedAt,
+    teamId,
+    tags
+  };
 }
 
 // src/domains/flows/pull/safety.ts
@@ -25010,7 +26691,7 @@ async function checkSafety(args) {
 }
 
 // src/domains/flows/pull/reportPull.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 function reportPullResult(ui, args) {
   if (ui.mode !== "json")
     return;
@@ -25025,12 +26706,12 @@ function reportPullResult(ui, args) {
     assetDownloadedCount: args.assets.downloadedCount,
     assetReusedCount: args.assets.reusedCount,
     assetSkippedCount: args.assets.skippedCount,
-    manifestPath: join27(args.stage.envDir, manifestFilename)
+    manifestPath: join28(args.stage.envDir, manifestFilename)
   }, "");
 }
 
 // src/domains/flows/pull/bundle.ts
-import { join as join28, relative as relative6 } from "node:path";
+import { join as join29, relative as relative6 } from "node:path";
 async function flattenSingleWrapper(dir, fs = makeDefaultFs()) {
   const entries = await fs.readdir(dir);
   if (entries.length !== 1)
@@ -25038,12 +26719,12 @@ async function flattenSingleWrapper(dir, fs = makeDefaultFs()) {
   const innerName = entries[0];
   if (!innerName)
     return;
-  const inner = join28(dir, innerName);
+  const inner = join29(dir, innerName);
   const innerStat = await fs.stat(inner);
   if (!innerStat.isDirectory())
     return;
   for (const e of await fs.readdir(inner)) {
-    await fs.rename(join28(inner, e), join28(dir, e));
+    await fs.rename(join29(inner, e), join29(dir, e));
   }
   const leftovers = await fs.readdir(inner);
   if (leftovers.length > 0) {
@@ -25062,7 +26743,7 @@ async function buildManifest(args, fs = makeDefaultFs()) {
   const flowPaths = await walkForFlows(args.bundleDir, fs);
   const flows = await Promise.all(flowPaths.map(async (rel) => ({
     path: toPosix(rel),
-    contentHash: await hashFile(join28(args.bundleDir, rel), fs),
+    contentHash: await hashFile(join29(args.bundleDir, rel), fs),
     tags: args.tags?.byPath.get(toPosix(rel))
   })));
   return {
@@ -25086,7 +26767,7 @@ async function walkForFlows(root, fs) {
 async function walk(current, root, out, fs) {
   const entries = await fs.readdirWithTypes(current);
   for (const e of entries) {
-    const abs = join28(current, e.name);
+    const abs = join29(current, e.name);
     if (e.isDirectory()) {
       await walk(abs, root, out, fs);
     } else if (e.isFile() && flowExtensions.some((ext) => e.name.endsWith(ext))) {
@@ -25099,11 +26780,11 @@ async function sampleQawolfCommittedAt(bundleDir, fs = makeDefaultFs()) {
   const sample = flowPaths[0];
   if (!sample)
     return;
-  return (await fs.stat(join28(bundleDir, sample))).mtime.toISOString();
+  return (await fs.stat(join29(bundleDir, sample))).mtime.toISOString();
 }
 
 // src/domains/flows/pull/applyTeamStorageRewrite.ts
-import { join as join29, relative as relative7 } from "node:path";
+import { join as join30, relative as relative7 } from "node:path";
 
 // src/domains/flows/pull/rewriteTeamStorage.ts
 var runnerMountPrefix = "/home/wolf/team-storage/";
@@ -25139,7 +26820,7 @@ function isFlowFile(name) {
 async function walk2(dir, out, fs) {
   const entries = await fs.readdirWithTypes(dir);
   for (const e of entries) {
-    const abs = join29(dir, e.name);
+    const abs = join30(dir, e.name);
     if (e.isDirectory()) {
       await walk2(abs, out, fs);
     } else if (e.isFile() && isSourceFile(e.name)) {
@@ -25167,7 +26848,7 @@ async function applyTeamStorageRewrite(rootDir, fs = makeDefaultFs()) {
 }
 
 // src/domains/flows/pull/envVars.ts
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 
 // src/core/dotenv.ts
 var bareKeyPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -25232,7 +26913,7 @@ function unquote(escaped) {
 async function writeEnvFile(envDir, vars, fs = makeDefaultFs()) {
   if (Object.keys(vars).length === 0)
     return;
-  await fs.writeFile(join30(envDir, ".env"), serializeDotenv(vars), {
+  await fs.writeFile(join31(envDir, ".env"), serializeDotenv(vars), {
     mode: 384
   });
 }
@@ -25647,7 +27328,7 @@ var Jr = I.writev;
 var ht = Symbol("_autoClose");
 var H = Symbol("_close");
 var te = Symbol("_ended");
-var m3 = Symbol("_fd");
+var m4 = Symbol("_fd");
 var Ni = Symbol("_finished");
 var tt = Symbol("_flags");
 var Ai = Symbol("_flush");
@@ -25674,7 +27355,7 @@ var Me = Symbol("_defaultFlag");
 var bt = Symbol("_errored");
 var _t = class extends A2 {
   [bt] = false;
-  [m3];
+  [m4];
   [U2];
   [Ci];
   [j] = false;
@@ -25684,10 +27365,10 @@ var _t = class extends A2 {
   constructor(t, e) {
     if (e = e || {}, super(e), this.readable = true, this.writable = false, typeof t != "string")
       throw new TypeError("path must be a string");
-    this[bt] = false, this[m3] = typeof e.fd == "number" ? e.fd : undefined, this[U2] = t, this[Ci] = e.readSize || 16 * 1024 * 1024, this[j] = false, this[Fi] = typeof e.size == "number" ? e.size : 1 / 0, this[ee] = this[Fi], this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : true, typeof this[m3] == "number" ? this[zt]() : this[at]();
+    this[bt] = false, this[m4] = typeof e.fd == "number" ? e.fd : undefined, this[U2] = t, this[Ci] = e.readSize || 16 * 1024 * 1024, this[j] = false, this[Fi] = typeof e.size == "number" ? e.size : 1 / 0, this[ee] = this[Fi], this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : true, typeof this[m4] == "number" ? this[zt]() : this[at]();
   }
   get fd() {
-    return this[m3];
+    return this[m4];
   }
   get path() {
     return this[U2];
@@ -25702,7 +27383,7 @@ var _t = class extends A2 {
     I.open(this[U2], "r", (t, e) => this[Ht](t, e));
   }
   [Ht](t, e) {
-    t ? this[Ut](t) : (this[m3] = e, this.emit("open", e), this[zt]());
+    t ? this[Ut](t) : (this[m4] = e, this.emit("open", e), this[zt]());
   }
   [vi]() {
     return Buffer.allocUnsafe(Math.min(this[Ci], this[ee]));
@@ -25713,16 +27394,16 @@ var _t = class extends A2 {
       let t = this[vi]();
       if (t.length === 0)
         return process.nextTick(() => this[Ii](null, 0, t));
-      I.read(this[m3], t, 0, t.length, null, (e, i, r) => this[Ii](e, i, r));
+      I.read(this[m4], t, 0, t.length, null, (e, i, r) => this[Ii](e, i, r));
     }
   }
   [Ii](t, e, i) {
     this[j] = false, t ? this[Ut](t) : this[ki](e, i) && this[zt]();
   }
   [H]() {
-    if (this[ht] && typeof this[m3] == "number") {
-      let t = this[m3];
-      this[m3] = undefined, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
+    if (this[ht] && typeof this[m4] == "number") {
+      let t = this[m4];
+      this[m4] = undefined, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
     }
   }
   [Ut](t) {
@@ -25738,7 +27419,7 @@ var _t = class extends A2 {
       case "finish":
         return false;
       case "drain":
-        return typeof this[m3] == "number" && this[zt](), false;
+        return typeof this[m4] == "number" && this[zt](), false;
       case "error":
         return this[bt] ? false : (this[bt] = true, super.emit(t, ...e));
       default:
@@ -25761,7 +27442,7 @@ var Be = class extends _t {
       if (!this[j]) {
         this[j] = true;
         do {
-          let e = this[vi](), i = e.length === 0 ? 0 : I.readSync(this[m3], e, 0, e.length, null);
+          let e = this[vi](), i = e.length === 0 ? 0 : I.readSync(this[m4], e, 0, e.length, null);
           if (!this[ki](i, e))
             break;
         } while (true);
@@ -25773,9 +27454,9 @@ var Be = class extends _t {
     }
   }
   [H]() {
-    if (this[ht] && typeof this[m3] == "number") {
-      let t = this[m3];
-      this[m3] = undefined, I.closeSync(t), this.emit("close");
+    if (this[ht] && typeof this[m4] == "number") {
+      let t = this[m4];
+      this[m4] = undefined, I.closeSync(t), this.emit("close");
     }
   }
 };
@@ -25790,15 +27471,15 @@ var et = class extends Qr {
   [U2];
   [ie];
   [ht];
-  [m3];
+  [m4];
   [Me];
   [tt];
   [Ni] = false;
   [ot];
   constructor(t, e) {
-    e = e || {}, super(e), this[U2] = t, this[m3] = typeof e.fd == "number" ? e.fd : undefined, this[ie] = e.mode === undefined ? 438 : e.mode, this[ot] = typeof e.start == "number" ? e.start : undefined, this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : true;
+    e = e || {}, super(e), this[U2] = t, this[m4] = typeof e.fd == "number" ? e.fd : undefined, this[ie] = e.mode === undefined ? 438 : e.mode, this[ot] = typeof e.start == "number" ? e.start : undefined, this[ht] = typeof e.autoClose == "boolean" ? e.autoClose : true;
     let i = this[ot] !== undefined ? "r+" : "w";
-    this[Me] = e.flags === undefined, this[tt] = e.flags === undefined ? i : e.flags, this[m3] === undefined && this[at]();
+    this[Me] = e.flags === undefined, this[tt] = e.flags === undefined ? i : e.flags, this[m4] === undefined && this[at]();
   }
   emit(t, ...e) {
     if (t === "error") {
@@ -25809,7 +27490,7 @@ var et = class extends Qr {
     return super.emit(t, ...e);
   }
   get fd() {
-    return this[m3];
+    return this[m4];
   }
   get path() {
     return this[U2];
@@ -25821,16 +27502,16 @@ var et = class extends Qr {
     I.open(this[U2], this[tt], this[ie], (t, e) => this[Ht](t, e));
   }
   [Ht](t, e) {
-    this[Me] && this[tt] === "r+" && t && t.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t ? this[Ut](t) : (this[m3] = e, this.emit("open", e), this[gt] || this[Ai]());
+    this[Me] && this[tt] === "r+" && t && t.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t ? this[Ut](t) : (this[m4] = e, this.emit("open", e), this[gt] || this[Ai]());
   }
   end(t, e) {
-    return t && this.write(t, e), this[te] = true, !this[gt] && !this[Y].length && typeof this[m3] == "number" && this[Pt](null, 0), this;
+    return t && this.write(t, e), this[te] = true, !this[gt] && !this[Y].length && typeof this[m4] == "number" && this[Pt](null, 0), this;
   }
   write(t, e) {
-    return typeof t == "string" && (t = Buffer.from(t, e)), this[te] ? (this.emit("error", new Error("write() after end()")), false) : this[m3] === undefined || this[gt] || this[Y].length ? (this[Y].push(t), this[ke] = true, false) : (this[gt] = true, this[ve](t), true);
+    return typeof t == "string" && (t = Buffer.from(t, e)), this[te] ? (this.emit("error", new Error("write() after end()")), false) : this[m4] === undefined || this[gt] || this[Y].length ? (this[Y].push(t), this[ke] = true, false) : (this[gt] = true, this[ve](t), true);
   }
   [ve](t) {
-    I.write(this[m3], t, 0, t.length, this[ot], (e, i) => this[Pt](e, i));
+    I.write(this[m4], t, 0, t.length, this[ot], (e, i) => this[Pt](e, i));
   }
   [Pt](t, e) {
     t ? this[Ut](t) : (this[ot] !== undefined && typeof e == "number" && (this[ot] += e), this[Y].length ? this[Ai]() : (this[gt] = false, this[te] && !this[Ni] ? (this[Ni] = true, this[H](), this.emit("finish")) : this[ke] && (this[ke] = false, this.emit("drain"))));
@@ -25842,13 +27523,13 @@ var et = class extends Qr {
       this[ve](this[Y].pop());
     else {
       let t = this[Y];
-      this[Y] = [], Jr(this[m3], t, this[ot], (e, i) => this[Pt](e, i));
+      this[Y] = [], Jr(this[m4], t, this[ot], (e, i) => this[Pt](e, i));
     }
   }
   [H]() {
-    if (this[ht] && typeof this[m3] == "number") {
-      let t = this[m3];
-      this[m3] = undefined, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
+    if (this[ht] && typeof this[m4] == "number") {
+      let t = this[m4];
+      this[m4] = undefined, I.close(t, (e) => e ? this.emit("error", e) : this.emit("close"));
     }
   }
 };
@@ -25868,15 +27549,15 @@ var Wt = class extends et {
     this[Ht](null, t);
   }
   [H]() {
-    if (this[ht] && typeof this[m3] == "number") {
-      let t = this[m3];
-      this[m3] = undefined, I.closeSync(t), this.emit("close");
+    if (this[ht] && typeof this[m4] == "number") {
+      let t = this[m4];
+      this[m4] = undefined, I.closeSync(t), this.emit("close");
     }
   }
   [ve](t) {
     let e = true;
     try {
-      this[Pt](null, I.writeSync(this[m3], t, 0, t.length, this[ot])), e = false;
+      this[Pt](null, I.writeSync(this[m4], t, 0, t.length, this[ot])), e = false;
     } finally {
       if (e)
         try {
@@ -28674,8 +30355,8 @@ async function handleFlowsPull(ctx, opts, deps) {
     ctx.ui.error(validation.error);
     return { error: validation.error };
   }
-  const destAbs = resolve8(opts.out ?? join31(".qawolf", opts.env));
-  const assetsAbs = join31(dirname8(destAbs), "assets");
+  const destAbs = resolve8(opts.out ?? join32(".qawolf", opts.env));
+  const assetsAbs = join32(dirname8(destAbs), "assets");
   await resolvedDeps.fs.mkdir(assetsAbs, { recursive: true });
   const yes = opts.yes ?? false;
   let archive;
@@ -28721,6 +30402,7 @@ async function handleFlowsPull(ctx, opts, deps) {
         message: flowsMessages.pull.downloadingTeamStorageAssets,
         task: async (update) => {
           const result = await ctx.platformClient.syncTeamStorageAssets(assetsAbs, {
+            teamId: fetched.teamId,
             onProgress: ({ current, total }) => update(flowsMessages.pull.downloadingTeamStorageAssetsProgress(current, total))
           });
           if (!result.ok)
@@ -29009,10 +30691,10 @@ async function resolveEnvChoice(args) {
 
 // src/core/flowFailureHint.ts
 function flowFailureHint(errText, projectDir) {
-  const missingPackage = extractMissingPackage(errText);
-  if (missingPackage === undefined)
+  const missing = extractMissingSpecifier(errText);
+  if (missing === undefined)
     return;
-  return runnerMessages.moduleNotFoundHint(missingPackage, projectDir);
+  return missing.kind === "path-alias" ? runnerMessages.pathAliasNotFoundHint(missing.specifier, projectDir) : runnerMessages.moduleNotFoundHint(missing.specifier, projectDir);
 }
 
 // src/shell/reporter/createCompositeReporter.ts
@@ -29101,9 +30783,6 @@ ${hint}`);
   };
 }
 
-// src/domains/runner/runAndroidFlowUtils.ts
-import { parseExecutionTarget as parseExecutionTarget3 } from "@qawolf/flow-targets";
-
 // src/domains/runner/unsupportedDepNames.ts
 var unsupportedSharedDepNames = [
   "fetchLatestEnvironmentVariables",
@@ -29129,7 +30808,7 @@ function resolveAvdName(targetInput) {
     const { deviceModel, androidVersion } = raw.meta;
     return makeAvdName(deviceModel, androidVersion);
   }
-  const parsed = parseExecutionTarget3(raw);
+  const parsed = parseExecutionTarget(raw);
   if (parsed.platform !== "android") {
     throw new Error(`runAndroidFlow: expected an Android target, got platform "${parsed.platform}"`);
   }
@@ -29550,15 +31229,15 @@ async function defaultRunWebFlowDeps(envDir = process.cwd(), signals) {
 
 // src/domains/runtimeEnv/prepareRunDir.ts
 import { createHash as createHash4 } from "node:crypto";
-import { join as join39, resolve as resolve9 } from "node:path";
+import { join as join41, resolve as resolve9 } from "node:path";
 
 // src/domains/runtimeEnv/execSubpathImports.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 var flowSubpathImports = { "#playwright": "playwright" };
 var packageJsonSchema = looseObject({ imports: record(string2(), unknown()).catch({}) }).catch({ imports: {} });
 async function writeExecSubpathImports(args) {
   const { execDir, fs } = args;
-  const pkgPath = join32(execDir, "package.json");
+  const pkgPath = join33(execDir, "package.json");
   const pkg = packageJsonSchema.parse(await readPackageJson(pkgPath, fs));
   const merged = { ...pkg, imports: { ...pkg.imports, ...flowSubpathImports } };
   await fs.writeFile(pkgPath, JSON.stringify(merged, undefined, 2));
@@ -29580,10 +31259,10 @@ async function readPackageJson(pkgPath, fs) {
 }
 
 // src/domains/runtimeEnv/innerHop.ts
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 
 // src/domains/runtimeEnv/linkPinnedPackages.ts
-import { dirname as dirname9, join as join33 } from "node:path";
+import { dirname as dirname9, join as join34 } from "node:path";
 
 // src/domains/runtimeEnv/symlinkDir.ts
 import { symlink } from "node:fs/promises";
@@ -29595,16 +31274,16 @@ async function createDirSymlink(source, target) {
 // src/domains/runtimeEnv/linkPinnedPackages.ts
 async function linkPinnedPackages(args) {
   const { depsRoot, nodeModulesDir, fs } = args;
-  const managedModules = join33(depsRoot, "node_modules");
+  const managedModules = join34(depsRoot, "node_modules");
   await fs.mkdir(nodeModulesDir, { recursive: true });
   for (const { name } of pinnedPackages) {
     const segments = name.split("/");
-    const target = join33(nodeModulesDir, ...segments);
+    const target = join34(nodeModulesDir, ...segments);
     if (segments.length > 1) {
       await fs.mkdir(dirname9(target), { recursive: true });
     }
     await fs.rm(target, { recursive: true, force: true });
-    await createDirSymlink(join33(managedModules, ...segments), target);
+    await createDirSymlink(join34(managedModules, ...segments), target);
   }
 }
 
@@ -29613,18 +31292,18 @@ async function populateInnerHop(args) {
   const { depsRoot, execDir, fs } = args;
   await linkPinnedPackages({
     depsRoot,
-    nodeModulesDir: join34(execDir, "node_modules"),
+    nodeModulesDir: join35(execDir, "node_modules"),
     fs
   });
 }
 
 // src/domains/runtimeEnv/outerHop.ts
 import { lstat as lstat2 } from "node:fs/promises";
-import { dirname as dirname11, join as join36 } from "node:path";
+import { dirname as dirname11, join as join37 } from "node:path";
 
 // src/domains/runtimeEnv/carryOverPackages.ts
 import { lstat } from "node:fs/promises";
-import { dirname as dirname10, join as join35 } from "node:path";
+import { dirname as dirname10, join as join36 } from "node:path";
 
 // src/domains/runtimeEnv/carryOverPlan.ts
 var executorPackageNames = new Set(pinnedPackages.map((p) => p.name));
@@ -29646,12 +31325,12 @@ async function carryOverPackages(args) {
   const linked = [];
   for (const name of names) {
     const segments = name.split("/");
-    const target = join35(nodeModulesDir, ...segments);
+    const target = join36(nodeModulesDir, ...segments);
     if (await pathOccupied(target))
       continue;
     if (segments.length > 1)
       await fs.mkdir(dirname10(target), { recursive: true });
-    await createDirSymlink(join35(projectModulesDir, ...segments), target);
+    await createDirSymlink(join36(projectModulesDir, ...segments), target);
     linked.push(name);
   }
   return linked;
@@ -29674,18 +31353,18 @@ async function listPackageNames(dir, fs) {
   const names = [];
   for (const entry of entries) {
     if (!entry.startsWith("@")) {
-      if (fs.existsSync(join35(dir, entry, "package.json")))
+      if (fs.existsSync(join36(dir, entry, "package.json")))
         names.push(entry);
       continue;
     }
     let scoped;
     try {
-      scoped = await fs.readdir(join35(dir, entry));
+      scoped = await fs.readdir(join36(dir, entry));
     } catch {
       continue;
     }
     for (const inner of scoped) {
-      if (fs.existsSync(join35(dir, entry, inner, "package.json"))) {
+      if (fs.existsSync(join36(dir, entry, inner, "package.json"))) {
         names.push(`${entry}/${inner}`);
       }
     }
@@ -29703,7 +31382,7 @@ async function populateOuterHop(args) {
   const depNames = Object.keys(installableDeps);
   const { satisfying, rejected } = await findSatisfyingNodeModulesDir(projectDir, depNames, fs);
   if (satisfying !== undefined) {
-    await createDirSymlink(satisfying, join36(runDir, "node_modules"));
+    await createDirSymlink(satisfying, join37(runDir, "node_modules"));
     return { mode: "symlink", nodeModulesDir: satisfying };
   }
   if (depNames.length === 0)
@@ -29712,12 +31391,12 @@ async function populateOuterHop(args) {
   await installOuterDeps(runDir, installableDeps, fs, args.install ?? spawnNpmInstall);
   await linkPinnedPackages({
     depsRoot: args.depsRoot,
-    nodeModulesDir: join36(runDir, "node_modules"),
+    nodeModulesDir: join37(runDir, "node_modules"),
     fs
   });
   const carriedOver = await carryOverPackages({
-    projectModulesDir: join36(projectDir, "node_modules"),
-    nodeModulesDir: join36(runDir, "node_modules"),
+    projectModulesDir: join37(projectDir, "node_modules"),
+    nodeModulesDir: join37(runDir, "node_modules"),
     fs
   });
   return { mode: "install", depCount: depNames.length, rejected, carriedOver };
@@ -29726,10 +31405,10 @@ async function findSatisfyingNodeModulesDir(startDir, depNames, fs) {
   const rejected = [];
   let dir = startDir;
   while (true) {
-    const candidate = join36(dir, "node_modules");
+    const candidate = join37(dir, "node_modules");
     const stats = await lstatSafe(candidate);
     if (stats !== undefined && stats.isDirectory() && !stats.isSymbolicLink()) {
-      const missing = depNames.filter((name) => !fs.existsSync(join36(candidate, name, "package.json")));
+      const missing = depNames.filter((name) => !fs.existsSync(join37(candidate, name, "package.json")));
       if (missing.length === 0)
         return { satisfying: candidate, rejected };
       rejected.push({ dir: candidate, missing });
@@ -29750,7 +31429,7 @@ async function lstatSafe(path) {
 async function readInstallableDeps(projectDir, fs) {
   let content;
   try {
-    content = await fs.readFile(join36(projectDir, "package.json"));
+    content = await fs.readFile(join37(projectDir, "package.json"));
   } catch {
     return {};
   }
@@ -29768,8 +31447,8 @@ async function readInstallableDeps(projectDir, fs) {
   return Object.fromEntries(Object.entries(rawDeps).filter(([name]) => !executorPackageNames2.has(name)).filter((entry) => typeof entry[1] === "string"));
 }
 async function installOuterDeps(runDir, deps, fs, install) {
-  await fs.writeFile(join36(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
-  await fs.writeFile(join36(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
+  await fs.writeFile(join37(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
+  await fs.writeFile(join37(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
   const result = await install(runDir);
   if (result.exitCode !== 0) {
@@ -29777,16 +31456,266 @@ async function installOuterDeps(runDir, deps, fs, install) {
   }
 }
 
+// src/domains/runtimeEnv/rewriteStagedAliases.ts
+import { join as join38 } from "node:path";
+
+// src/core/aliasImports/rewriteAliasImports.ts
+import { posix as posix3 } from "node:path";
+
+// src/core/aliasImports/collectAliasSpecifiers.ts
+function isRelativeSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
+function collectAliasSpecifiers(options) {
+  const { sourceFile, typescript: compiler } = options;
+  const specifiers = [];
+  const addCandidate = (literal) => {
+    if (isRelativeSpecifier(literal.text))
+      return;
+    specifiers.push({
+      end: literal.getEnd(),
+      specifier: literal.text,
+      start: literal.getStart(sourceFile)
+    });
+  };
+  for (const statement of sourceFile.statements) {
+    if (compiler.isImportDeclaration(statement)) {
+      const phase = statement.importClause?.phaseModifier;
+      if (phase === compiler.SyntaxKind.TypeKeyword)
+        continue;
+      if (compiler.isStringLiteral(statement.moduleSpecifier)) {
+        addCandidate(statement.moduleSpecifier);
+      }
+      continue;
+    }
+    if (compiler.isExportDeclaration(statement) && !statement.isTypeOnly) {
+      const { moduleSpecifier } = statement;
+      if (moduleSpecifier !== undefined && compiler.isStringLiteral(moduleSpecifier)) {
+        addCandidate(moduleSpecifier);
+      }
+    }
+  }
+  const visit = (node) => {
+    if (compiler.isCallExpression(node) && node.expression.kind === compiler.SyntaxKind.ImportKeyword) {
+      const [firstArgument] = node.arguments;
+      if (firstArgument !== undefined && (compiler.isStringLiteral(firstArgument) || compiler.isNoSubstitutionTemplateLiteral(firstArgument))) {
+        addCandidate(firstArgument);
+      }
+      return;
+    }
+    compiler.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return specifiers;
+}
+
+// src/core/aliasImports/filePathVariants.ts
+var sourceExtensionPattern = /\.(js|ts)$/;
+var sourceExtensions2 = [".ts", ".js"];
+function filePathVariants(importPath) {
+  const hasSourceExtension = sourceExtensionPattern.test(importPath);
+  const base = importPath.replace(sourceExtensionPattern, "");
+  const siblings = sourceExtensions2.map((extension) => base + extension);
+  const indexes = hasSourceExtension ? [] : sourceExtensions2.map((extension) => `${base}/index${extension}`);
+  return [...new Set([importPath, ...siblings, ...indexes])];
+}
+
+// src/core/aliasImports/tsconfigPaths.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTsconfigPaths(value) {
+  return isRecord2(value) && Object.values(value).every((targets) => Array.isArray(targets) && targets.every((target) => typeof target === "string"));
+}
+function parseTsconfigContent(tsconfigContent) {
+  let parsed;
+  try {
+    parsed = JSON.parse(tsconfigContent);
+  } catch {
+    return { type: "unparseable" };
+  }
+  if (!isRecord2(parsed))
+    return { paths: undefined, type: "parsed" };
+  const compilerOptions = parsed["compilerOptions"];
+  if (!isRecord2(compilerOptions))
+    return { paths: undefined, type: "parsed" };
+  const paths = compilerOptions["paths"];
+  return {
+    paths: isTsconfigPaths(paths) ? paths : undefined,
+    type: "parsed"
+  };
+}
+function parseTsconfigPaths(tsconfigContent) {
+  const parsed = parseTsconfigContent(tsconfigContent);
+  return parsed.type === "parsed" ? parsed.paths : undefined;
+}
+function parseWildcardPattern(pattern) {
+  const wildcard = pattern.indexOf("*");
+  if (wildcard === -1 || wildcard !== pattern.lastIndexOf("*"))
+    return;
+  return {
+    prefix: pattern.slice(0, wildcard),
+    suffix: pattern.slice(wildcard + 1)
+  };
+}
+function matchesWildcard(importPath, { prefix, suffix }) {
+  return importPath.length >= prefix.length + suffix.length && importPath.startsWith(prefix) && importPath.endsWith(suffix);
+}
+function longestPrefixMatch(importPath, paths) {
+  return Object.entries(paths).flatMap(([pattern, targets]) => {
+    const parsed = parseWildcardPattern(pattern);
+    if (parsed === undefined || !matchesWildcard(importPath, parsed)) {
+      return [];
+    }
+    return [{ pattern: parsed, targets }];
+  }).reduce((best, candidate) => best === undefined || candidate.pattern.prefix.length > best.pattern.prefix.length ? candidate : best, undefined);
+}
+function resolvePathAlias(importPath, paths) {
+  if (paths === undefined)
+    return;
+  const [exactTarget] = paths[importPath] ?? [];
+  if (exactTarget !== undefined)
+    return exactTarget;
+  const match = longestPrefixMatch(importPath, paths);
+  if (match === undefined)
+    return;
+  const [target] = match.targets;
+  if (target === undefined)
+    return;
+  const substituted = importPath.slice(match.pattern.prefix.length, importPath.length - match.pattern.suffix.length);
+  return target.replace("*", substituted);
+}
+
+// src/core/aliasImports/rewriteAliasImports.ts
+function findTargetFilePath(options) {
+  return filePathVariants(posix3.normalize(options.aliasTarget)).find((candidate) => options.projectFilePaths.has(candidate));
+}
+function toRelativeSpecifier(options) {
+  const relativePath = posix3.relative(posix3.dirname(options.importingFilePath), options.targetFilePath);
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function applyEdit(code, edit) {
+  const quote = code.slice(edit.start, edit.start + 1);
+  return code.slice(0, edit.start) + quote + edit.relativeSpecifier + quote + code.slice(edit.end);
+}
+function rewriteAliasImports(options) {
+  const { code, importingFilePath, projectFilePaths, tsconfigPaths } = options;
+  const compiler = options.typescript;
+  if (tsconfigPaths === undefined)
+    return code;
+  const sourceFile = compiler.createSourceFile(importingFilePath, code, compiler.ScriptTarget.Latest, true);
+  const edits = collectAliasSpecifiers({
+    sourceFile,
+    typescript: compiler
+  }).flatMap((candidate) => {
+    const aliasTarget = resolvePathAlias(candidate.specifier, tsconfigPaths);
+    if (aliasTarget === undefined)
+      return [];
+    const targetFilePath = findTargetFilePath({
+      aliasTarget,
+      projectFilePaths
+    });
+    if (targetFilePath === undefined)
+      return [];
+    return [
+      {
+        end: candidate.end,
+        relativeSpecifier: toRelativeSpecifier({
+          importingFilePath,
+          targetFilePath
+        }),
+        start: candidate.start
+      }
+    ];
+  });
+  return edits.sort((left, right) => right.start - left.start).reduce(applyEdit, code);
+}
+
+// src/domains/runtimeEnv/rewriteStagedAliases.ts
+var skippedDirs = new Set(["node_modules", ".git", ".qawolf"]);
+var sourceExtensions3 = [".ts", ".js"];
+async function rewriteStagedAliases(args) {
+  const tsconfig = await readStagedTsconfig(args);
+  if (tsconfig.type === "unparseable") {
+    args.onTsconfigUnparsed?.();
+    return [];
+  }
+  if (tsconfig.type === "absent" || tsconfig.paths === undefined)
+    return [];
+  const tsconfigPaths = tsconfig.paths;
+  const stagedPaths = await listStagedSourceFiles({
+    dir: args.execDir,
+    fs: args.fs,
+    prefix: ""
+  });
+  const projectFilePaths = new Set(stagedPaths);
+  const aliasPrefixes = Object.keys(tsconfigPaths).map((pattern) => pattern.split("*")[0] ?? pattern);
+  const mentionsAnAlias = (code) => aliasPrefixes.some((prefix) => code.includes(prefix));
+  const { default: typescript } = await import("typescript");
+  const rewriteOne = async (stagedPath) => {
+    const absolutePath = join38(args.execDir, stagedPath);
+    const code = await args.fs.readFile(absolutePath);
+    if (!mentionsAnAlias(code))
+      return;
+    const rewritten = rewriteAliasImports({
+      code,
+      importingFilePath: stagedPath,
+      projectFilePaths,
+      tsconfigPaths,
+      typescript
+    });
+    if (rewritten === code)
+      return;
+    await args.fs.writeFile(absolutePath, rewritten);
+    return stagedPath;
+  };
+  const rewrittenPaths = [];
+  for await (const stagedPath of batchMap(stagedPaths, rewriteOne, flowBatchSize)) {
+    if (stagedPath !== undefined)
+      rewrittenPaths.push(stagedPath);
+  }
+  return rewrittenPaths;
+}
+async function readStagedTsconfig(options) {
+  let content;
+  try {
+    content = await options.fs.readFile(join38(options.execDir, "tsconfig.json"));
+  } catch (err) {
+    if (isNoEntError(err))
+      return { type: "absent" };
+    throw err;
+  }
+  return parseTsconfigContent(content);
+}
+async function listStagedSourceFiles(options) {
+  const entries = await options.fs.readdirWithTypes(options.dir);
+  const nested = await Promise.all(entries.map(async (entry) => {
+    if (skippedDirs.has(entry.name))
+      return [];
+    const stagedPath = options.prefix === "" ? entry.name : `${options.prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      return listStagedSourceFiles({
+        dir: join38(options.dir, entry.name),
+        fs: options.fs,
+        prefix: stagedPath
+      });
+    }
+    const isSource = sourceExtensions3.some((extension) => entry.name.endsWith(extension));
+    return entry.isFile() && isSource ? [stagedPath] : [];
+  }));
+  return nested.flat();
+}
+
 // src/domains/runtimeEnv/stageFlowFiles.ts
 import { createHash as createHash3 } from "node:crypto";
-import { basename as basename6, dirname as dirname12, join as join38, sep as sep4 } from "node:path";
+import { basename as basename6, dirname as dirname12, join as join40, sep as sep4 } from "node:path";
 
 // src/shell/copyDir.ts
 import { cp, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename5, join as join37 } from "node:path";
+import { basename as basename5, join as join39 } from "node:path";
 async function copyDirExcluding(source, destination, excludedNames) {
   const entries = await readdir2(source, { withFileTypes: true });
-  await Promise.all(entries.filter((entry) => !excludedNames.has(entry.name)).map((entry) => cp(join37(source, entry.name), join37(destination, entry.name), {
+  await Promise.all(entries.filter((entry) => !excludedNames.has(entry.name)).map((entry) => cp(join39(source, entry.name), join39(destination, entry.name), {
     recursive: true,
     filter: (path) => !excludedNames.has(basename5(path))
   })));
@@ -29803,14 +31732,14 @@ async function stageFlowFiles(args) {
   if (files.length > 1) {
     return Promise.all(files.map((f) => stageOneFile(f, execDir, fs)));
   }
-  await Promise.all(files.map((f) => fs.copyFile(f, join38(execDir, basename6(f)))));
-  return files.map((f) => join38(execDir, basename6(f)));
+  await Promise.all(files.map((f) => fs.copyFile(f, join40(execDir, basename6(f)))));
+  return files.map((f) => join40(execDir, basename6(f)));
 }
 async function stageOneFile(file, execDir, fs) {
   const dirHash = createHash3("sha256").update(dirname12(file)).digest("hex").slice(0, 8);
-  const subDir = join38(execDir, dirHash);
+  const subDir = join40(execDir, dirHash);
   await fs.mkdir(subDir, { recursive: true });
-  const dest = join38(subDir, basename6(file));
+  const dest = join40(subDir, basename6(file));
   await fs.copyFile(file, dest);
   return dest;
 }
@@ -29818,7 +31747,7 @@ function remapPath(file, projectDir, execDir) {
   if (file === projectDir)
     return execDir;
   if (file.startsWith(projectDir + sep4)) {
-    return join38(execDir, file.slice(projectDir.length + 1));
+    return join40(execDir, file.slice(projectDir.length + 1));
   }
   return;
 }
@@ -29828,15 +31757,21 @@ async function prepareRunDir(args) {
   const { files, projectDir, depsRoot, runRoot } = args;
   const fs = args.fs ?? makeDefaultFs();
   const runId = buildRunId(projectDir, files);
-  const runDir = join39(runRoot, runId);
+  const runDir = join41(runRoot, runId);
   await fs.rm(runDir, { recursive: true, force: true });
   await fs.mkdir(runDir, { recursive: true });
-  const execDir = join39(runDir, "exec");
+  const execDir = join41(runDir, "exec");
   await fs.mkdir(execDir, { recursive: true });
   await populateInnerHop({ depsRoot, execDir, fs });
   const stagedFiles = await stageFlowFiles({ files, projectDir, execDir, fs });
   if (projectDir !== undefined) {
     await writeExecSubpathImports({ execDir, fs });
+    const onTsconfigUnparsed = args.onTsconfigUnparsed;
+    await rewriteStagedAliases({
+      execDir,
+      fs,
+      ...onTsconfigUnparsed !== undefined ? { onTsconfigUnparsed: () => onTsconfigUnparsed(projectDir) } : {}
+    });
   }
   const outerHop = await populateOuterHop({
     projectDir,
@@ -29862,17 +31797,17 @@ function buildRunId(projectDir, files) {
 }
 
 // src/shell/testkit.ts
-import { join as join40 } from "node:path";
+import { join as join42 } from "node:path";
 function notAvailableLocally(name) {
   throw new Error(runnerMessages.notAvailableLocally(name));
 }
 async function loadSdkDeps(cwd) {
-  const testkitDir = join40(cwd, "node_modules", "@qawolf", "testkit");
+  const testkitDir = join42(cwd, "node_modules", "@qawolf", "testkit");
   try {
     const clientMod = await importFromPath(resolveFromEnvDir(cwd, "@qawolf/testkit/client"));
     if (typeof clientMod.createTestkitClient !== "function")
       throw new Error("createTestkitClient is not a function");
-    const scopeMod = await importFromPath(join40(testkitDir, "dist", "clientScope.js"));
+    const scopeMod = await importFromPath(join42(testkitDir, "dist", "clientScope.js"));
     if (typeof scopeMod.configureTestkitClient !== "function")
       throw new Error("configureTestkitClient is not a function");
     return {
@@ -29930,9 +31865,9 @@ async function registerLazyEmailsClient(getInbox, cwd, deps) {
 }
 
 // src/commands/flows/envVarDeps.ts
-import { join as join41 } from "node:path";
+import { join as join43 } from "node:path";
 function envFilePath(envDir) {
-  return join41(envDir, ".env");
+  return join43(envDir, ".env");
 }
 async function readEnv(envDir, fs) {
   try {
@@ -30056,7 +31991,7 @@ async function selectRunByTag(args) {
 }
 
 // src/commands/flows/runStagedFlows.ts
-import { join as join45 } from "node:path";
+import { join as join47 } from "node:path";
 
 // src/shell/appium/createAppiumServer.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -30190,7 +32125,7 @@ var defaultAdb = async (args) => {
 
 // src/shell/appium/createAndroidEmulator.ts
 var defaultBootTimeoutMs = 120000;
-var pollIntervalMs = 2000;
+var pollIntervalMs2 = 2000;
 var defaultSpawnEmulator = (bin, args) => {
   const child = spawn3(bin, args, { stdio: "ignore" });
   child.unref();
@@ -30208,7 +32143,7 @@ async function bootSequence(adb, serial, cancelled) {
     ]).catch(() => ({ stdout: "" }));
     if (stdout.trim() === "1")
       return;
-    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    await new Promise((r) => setTimeout(r, pollIntervalMs2));
   }
 }
 function waitForBoot(adb, serial, timeoutMs) {
@@ -31362,14 +33297,14 @@ async function runWebFlow({
 
 // src/shell/embeddedWorkerCli.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename7, join as join42 } from "node:path";
+import { basename as basename7, join as join44 } from "node:path";
 var embeddedCliPathEnv = "QAWOLF_EMBEDDED_CLI_PATH";
 function extractEmbeddedWorkerCli() {
   const assetPath = process.env[embeddedCliPathEnv];
   if (assetPath === undefined || assetPath === "")
     return;
-  const dir = join42(getDataDir(), "worker");
-  const dest = join42(dir, basename7(assetPath));
+  const dir = join44(getDataDir(), "worker");
+  const dest = join44(dir, basename7(assetPath));
   if (existsSync3(dest))
     return dest;
   mkdirSync3(dir, { recursive: true });
@@ -31527,33 +33462,33 @@ function makePooledDispatch(resolvedDir) {
 import { dirname as dirname13 } from "node:path";
 
 // src/shell/reporter/createConsoleReporter.ts
-import { styleText as styleText3 } from "node:util";
+import { styleText as styleText5 } from "node:util";
 function fmtDuration(ms) {
   return `(${(ms / 1000).toFixed(2)}s)`;
 }
 function fmtStampLine(manifest) {
   const shortHash = manifest.contentHash.slice(0, 8);
-  return `    ${styleText3("dim", `env=${manifest.envId} hash=${shortHash}`)}
+  return `    ${styleText5("dim", `env=${manifest.envId} hash=${shortHash}`)}
 `;
 }
 function createConsoleReporter(deps) {
   return {
     onFlowStart({ name, path }) {
-      deps.stdout.write(`${styleText3("magenta", "•")} ${styleText3(["bold", "magenta"], name)} ${styleText3("dim", path)}
+      deps.stdout.write(`${styleText5("magenta", "•")} ${styleText5(["bold", "magenta"], name)} ${styleText5("dim", path)}
 `);
     },
     onTestResult({ label, status, durationMs }) {
-      const icon = status === "pass" ? styleText3("green", "✓") : styleText3("red", "✗");
-      deps.stdout.write(`  - ${label}  ${icon} ${styleText3("dim", fmtDuration(durationMs))}
+      const icon = status === "pass" ? styleText5("green", "✓") : styleText5("red", "✗");
+      deps.stdout.write(`  - ${label}  ${icon} ${styleText5("dim", fmtDuration(durationMs))}
 `);
     },
     onScreenshot({ path }) {
-      deps.stdout.write(`    ${styleText3("dim", runnerMessages.screenshot(path))}
+      deps.stdout.write(`    ${styleText5("dim", runnerMessages.screenshot(path))}
 `);
     },
     onFlowPass({ tests, durationMs, manifest }) {
       const counts = tests.total > 0 ? `${tests.passed}/${tests.total} tests ` : "";
-      deps.stdout.write(`  ${styleText3("green", "✓")} ${counts}passed ${styleText3("dim", fmtDuration(durationMs))}
+      deps.stdout.write(`  ${styleText5("green", "✓")} ${counts}passed ${styleText5("dim", fmtDuration(durationMs))}
 `);
       if (manifest)
         deps.stdout.write(fmtStampLine(manifest));
@@ -31564,8 +33499,8 @@ function createConsoleReporter(deps) {
 `);
       const indent = "    ";
       const formatted = [
-        styleText3("red", `${indent}${firstLine}`),
-        ...restLines.map((line) => styleText3("dim", `${indent}${line}`))
+        styleText5("red", `${indent}${firstLine}`),
+        ...restLines.map((line) => styleText5("dim", `${indent}${line}`))
       ].join(`
 `);
       deps.stderr.write(`${formatted}
@@ -31573,12 +33508,12 @@ function createConsoleReporter(deps) {
 `);
       const hint = flowFailureHint(errStr, deps.projectDir);
       if (hint !== undefined) {
-        deps.stderr.write(`${styleText3("yellow", `${indent}${hint}`)}
+        deps.stderr.write(`${styleText5("yellow", `${indent}${hint}`)}
 
 `);
       }
       const counts = tests.total > 0 ? `${tests.passed}/${tests.total} tests ` : "";
-      deps.stdout.write(`  ${styleText3("red", "✗")} ${counts}passed ${styleText3("dim", fmtDuration(durationMs))}
+      deps.stdout.write(`  ${styleText5("red", "✗")} ${counts}passed ${styleText5("dim", fmtDuration(durationMs))}
 `);
       if (manifest)
         deps.stdout.write(fmtStampLine(manifest));
@@ -31593,21 +33528,21 @@ ${runnerMessages.retrying(attempt, maxAttempts)}
       if (total <= 1)
         return;
       const allPassed = summary.flowsFailed === 0;
-      const icon = styleText3(allPassed ? "green" : "red", allPassed ? "✓" : "✗");
+      const icon = styleText5(allPassed ? "green" : "red", allPassed ? "✓" : "✗");
       const skippedStr = summary.flowsSkipped > 0 ? ` (${summary.flowsSkipped} skipped)` : "";
       const flowCount = `${summary.flowsPassed}/${total} flows passed${skippedStr}`;
       const testCount = summary.testsTotal > 0 ? ` · ${summary.testsPassed}/${summary.testsTotal} tests passed` : "";
       const width = deps.columns ?? process.stdout.columns ?? 72;
       deps.stdout.write(`
-${styleText3("dim", "─".repeat(width))}
+${styleText5("dim", "─".repeat(width))}
 `);
-      deps.stdout.write(`  ${icon} ${flowCount}${testCount} ${styleText3("dim", fmtDuration(summary.durationMs))}
+      deps.stdout.write(`  ${icon} ${flowCount}${testCount} ${styleText5("dim", fmtDuration(summary.durationMs))}
 `);
     }
   };
 }
 // src/shell/reporter/createJUnitReporter.ts
-import { join as join43 } from "node:path";
+import { join as join45 } from "node:path";
 
 // src/shell/reporter/junitXml.ts
 function escapeXml(str) {
@@ -31646,7 +33581,7 @@ ${suites}`;
 
 // src/shell/reporter/createJUnitReporter.ts
 function resolveJUnitOutputPath(junit, outputDir) {
-  return typeof junit === "string" && junit.trim() !== "" ? junit : join43(outputDir, "junit-report.xml");
+  return typeof junit === "string" && junit.trim() !== "" ? junit : join45(outputDir, "junit-report.xml");
 }
 function createJUnitReporter(deps) {
   const flows = [];
@@ -31737,11 +33672,11 @@ function buildFlowsRunDeps(args) {
 
 // src/commands/flows/loadEnvFile.ts
 import { readFile } from "node:fs/promises";
-import { join as join44 } from "node:path";
+import { join as join46 } from "node:path";
 async function loadEnvFile(envDir) {
   let content;
   try {
-    content = await readFile(join44(envDir, ".env"), "utf8");
+    content = await readFile(join46(envDir, ".env"), "utf8");
   } catch (err) {
     if (isNoEntError(err))
       return;
@@ -31779,14 +33714,15 @@ async function runStagedFlows(args) {
     projectDir,
     depsRoot: runtimeEnv.depsRoot,
     runRoot: runStagingRoot(),
-    onInstallStart: (depCount) => ctx.ui.info(runnerMessages.installingProjectDeps(depCount))
+    onInstallStart: (depCount) => ctx.ui.info(runnerMessages.installingProjectDeps(depCount)),
+    onTsconfigUnparsed: (dir) => ctx.ui.warn(runnerMessages.tsconfigUnparsedNotice(dir))
   });
   if (staged.outerHop.mode === "install") {
     const log = ctx.log("runner");
     for (const candidate of staged.outerHop.rejected) {
       log.debug(runnerMessages.outerHopCandidateRejected(candidate.dir, candidate.missing));
     }
-    const ownModules = projectDir === undefined ? undefined : join45(projectDir, "node_modules");
+    const ownModules = projectDir === undefined ? undefined : join47(projectDir, "node_modules");
     const own = staged.outerHop.rejected.find((c) => c.dir === ownModules);
     if (own !== undefined) {
       ctx.ui.warn(runnerMessages.outerHopFallbackNotice(own.dir, own.missing));
@@ -31882,7 +33818,7 @@ async function chooseEnv(ctx, files, allEnvs) {
 }
 
 // src/commands/flows/hybridRunDefaults.ts
-import { join as join46, resolve as resolve10 } from "node:path";
+import { join as join48, resolve as resolve10 } from "node:path";
 
 // src/core/selectFlowFiles.ts
 function selectFlowFiles(args) {
@@ -31987,7 +33923,7 @@ async function handleHybridFlowsRun(ctx, pattern, flags, options = {}) {
   if (validation !== "ok") {
     return { error: validation.error, exitCode: 2 };
   }
-  const envDir = resolve10(join46(".qawolf", flags.env));
+  const envDir = resolve10(join48(".qawolf", flags.env));
   const patternArgs = buildPatternArgs(pattern);
   const globFlows = () => resolvedDeps.expandPatterns(patternArgs, envDir, ctx.log("flows"));
   let files = await globFlows();
@@ -32183,12 +34119,12 @@ function registerFlowsCommand(program, signals, deps = { withResolvedEnv }) {
 }
 
 // src/domains/init/init.ts
-import { dirname as dirname14, join as join48, relative as relative9 } from "node:path";
+import { dirname as dirname14, join as join50, relative as relative9 } from "node:path";
 
 // src/domains/init/ensurePackageJson.ts
-import { join as join47 } from "node:path";
+import { join as join49 } from "node:path";
 async function ensurePackageJson(ctx, yes, deps) {
-  const pkgPath = join47(deps.cwd, "package.json");
+  const pkgPath = join49(deps.cwd, "package.json");
   if (!await deps.fs.pathExists(pkgPath)) {
     const confirmed = await ctx.ui.confirm(initMessages.createPackageJsonPrompt, { yes });
     if (!confirmed.ok || !confirmed.value) {
@@ -32214,7 +34150,7 @@ async function ensurePackageJson(ctx, yes, deps) {
     ctx.ui.warn(initMessages.packageJsonInvalidJson);
     return;
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     ctx.ui.warn(initMessages.packageJsonNotAnObject);
     return;
   }
@@ -32265,14 +34201,14 @@ async function ensurePackageJson(ctx, yes, deps) {
     ctx.ui.warn(initMessages.typeChanged(label));
   }
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readSection(ctx, pkg, key) {
   const value = pkg[key];
   if (value === undefined)
     return {};
-  if (isRecord2(value))
+  if (isRecord3(value))
     return value;
   ctx.ui.warn(initMessages.packageJsonMalformedSection(key));
   return;
@@ -32314,9 +34250,9 @@ function makeDefaultInitDeps() {
 async function handleInit(ctx, opts, deps = makeDefaultInitDeps()) {
   ctx.ui.gap();
   ctx.ui.intro(initMessages.title);
-  const configPath = join48(deps.cwd, "qawolf.config.ts");
-  const flowPath = join48(deps.cwd, "src", "flows", "example.flow.ts");
-  const gitignorePath = join48(deps.cwd, ".qawolf", ".gitignore");
+  const configPath = join50(deps.cwd, "qawolf.config.ts");
+  const flowPath = join50(deps.cwd, "src", "flows", "example.flow.ts");
+  const gitignorePath = join50(deps.cwd, ".qawolf", ".gitignore");
   await writeWithPrompt(ctx, configPath, qawolfConfigTs, opts.yes, deps);
   await writeWithPrompt(ctx, flowPath, exampleFlowTs, opts.yes, deps);
   await writeWithPrompt(ctx, gitignorePath, qawolfGitignore, opts.yes, deps);
@@ -32350,11 +34286,8 @@ Examples:
   });
 }
 
-// src/domains/install/android/index.ts
-import { parseExecutionTarget as parseExecutionTarget4 } from "@qawolf/flow-targets";
-
 // src/domains/install/android/avd.ts
-import { join as join49 } from "node:path";
+import { join as join51 } from "node:path";
 async function installAvds(ctx, specs, deps) {
   const sdkManagerPath = sdkManagerBin(deps.androidHome, deps.platform);
   const avdManagerPath = avdManagerBin(deps.androidHome, deps.platform);
@@ -32364,7 +34297,7 @@ async function installAvds(ctx, specs, deps) {
   if (versionResult.exitCode !== 0) {
     throw new Error(installMessages.android.sdkmanagerNotFound(sdkManagerPath));
   }
-  const licenseFile = join49(deps.androidHome, "licenses", "android-sdk-license");
+  const licenseFile = join51(deps.androidHome, "licenses", "android-sdk-license");
   if (deps.checkExists(licenseFile)) {
     ctx.ui.info(installMessages.android.licensesAlreadyAccepted);
   } else {
@@ -32379,7 +34312,7 @@ async function installAvds(ctx, specs, deps) {
   for (const spec of specs) {
     if (installedImages.has(spec.systemImage))
       continue;
-    const systemImg = join49(deps.androidHome, ...spec.systemImage.split(";"), "system.img");
+    const systemImg = join51(deps.androidHome, ...spec.systemImage.split(";"), "system.img");
     if (deps.checkExists(systemImg)) {
       ctx.ui.info(installMessages.android.systemImageAlreadyInstalled(spec.systemImage));
       installedImages.add(spec.systemImage);
@@ -32492,7 +34425,7 @@ function buildAvdSpecs(targets, arch) {
     const avdName = avdNameForTarget(target);
     if (!avdName || seen.has(avdName))
       continue;
-    const parsed = parseExecutionTarget4(target);
+    const parsed = parseExecutionTarget(target);
     if (parsed.platform !== "android")
       continue;
     const { deviceModel, androidVersion } = parsed.meta;
@@ -32820,14 +34753,14 @@ function parseKeyValueRecord(flag, pairs) {
   }
   return { ok: true, record };
 }
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function setAtPath(input, path, value) {
   const leaf = path[path.length - 1];
   if (leaf === undefined)
     return;
   const target = path.slice(0, -1).reduce((node, segment) => {
     const existing = node[segment];
-    const next = isRecord3(existing) ? existing : {};
+    const next = isRecord4(existing) ? existing : {};
     node[segment] = next;
     return next;
   }, input);
@@ -32881,6 +34814,8 @@ async function handlePublicApiCommand(ctx, spec, options) {
 
 // src/domains/publicApi/skippedContracts.ts
 var skippedContractNames = new Set([
+  "agent.get",
+  "agent.send",
   "flow.list",
   "runner.evaluateSnippet",
   "runner.get",
@@ -32899,34 +34834,6 @@ var skippedContractNames = new Set([
   "runner.terminate"
 ]);
 
-// src/commands/publicApi/environmentOptions.ts
-var optionEnvironmentVariables = new Map([
-  ["environmentId", "QAWOLF_ENVIRONMENT"],
-  ["public.run.create.aiTaskId", "QAWOLF_AI_TASK_ID"],
-  ["public.run.create.chatSessionId", "QAWOLF_CHAT_SESSION_ID"]
-]);
-function optionEnvironmentVariable(spec, path) {
-  const dotted = path.join(".");
-  return optionEnvironmentVariables.get(`${spec.trpcPath}.${dotted}`) ?? optionEnvironmentVariables.get(dotted);
-}
-var exclusiveOptions = new Map([
-  ["public.run.create", { keep: "aiTaskId", drop: "chatSessionId" }]
-]);
-function withoutExclusiveConflict(spec, command, options) {
-  const pair = exclusiveOptions.get(spec.trpcPath);
-  if (!pair)
-    return options;
-  if (options[pair.keep] === undefined || options[pair.drop] === undefined) {
-    return options;
-  }
-  const fromEnvironment = (key) => command.getOptionValueSource(key) === "env";
-  if (!fromEnvironment(pair.keep) && !fromEnvironment(pair.drop)) {
-    return options;
-  }
-  const dropped = fromEnvironment(pair.drop) ? pair.drop : pair.keep;
-  return Object.fromEntries(Object.entries(options).filter(([key]) => key !== dropped));
-}
-
 // src/commands/publicApi/index.ts
 var groupDescriptions = {
   run: "Trigger and manage QA Wolf runs on the platform"
@@ -33063,19 +34970,17 @@ function parseRunnerName(runnerName) {
 
 // src/domains/interactiveRunner/resolveRunner.ts
 var runnerIdEnvironmentVariable = "QAWOLF_RUNNER_ID";
-async function chooseRunnerId(runner, deps) {
-  if (runner !== undefined)
-    return runner;
-  const fromEnvironment = deps.env[runnerIdEnvironmentVariable]?.trim();
-  if (fromEnvironment)
-    return fromEnvironment;
-  return deps.store.readDefaultRunnerId();
-}
+var chooseRunnerId = (runner, deps) => resolveIdFrom({
+  env: deps.env,
+  environmentVariable: runnerIdEnvironmentVariable,
+  given: runner,
+  readStored: deps.store.readDefaultRunnerId
+});
 async function resolveRunner(ctx, options, deps) {
   const chosen = await chooseRunnerId(options.runner, deps);
   if (chosen !== undefined) {
-    const parsed = parseRunnerId(chosen);
-    return parsed.ok ? { runnerId: parsed.id, type: "resolved" } : {
+    const parsed = parseRunnerId(chosen.id);
+    return parsed.ok ? { runnerId: parsed.id, source: chosen.source, type: "resolved" } : {
       error: parsed.error,
       exitCode: exitCodes.invalidArgs,
       type: "failed"
@@ -33096,12 +35001,32 @@ async function resolveRunner(ctx, options, deps) {
       type: "failed"
     };
   }
-  return { runnerId: launched.value.id, type: "launched" };
+  return {
+    runnerId: launched.value.id,
+    source: "launched",
+    type: "launched",
+    url: launched.value.url
+  };
 }
 function announceRunner(ctx, resolved) {
   if (resolved.type === "launched") {
-    ctx.ui.info(interactiveRunnerMessages.launchedForCommand(resolved.runnerId));
+    ctx.ui.info(interactiveRunnerMessages.launchedForCommand(resolved.runnerId, resolved.url));
+  }
+}
+
+// src/domains/interactiveRunner/runnerRequestFailure.ts
+function runnerRequestFailure(failure, runner) {
+  const fields = failureFields(failure);
+  if (failure.exitCode !== exitCodes.notFound) {
+    return { ...fields, exitCode: failure.exitCode ?? exitCodes.network };
   }
+  const cameFrom = interactiveRunnerMessages.runnerIdCameFrom(runner.runnerId, runner.source);
+  return {
+    ...fields,
+    errorBody: fields.errorBody ? `${fields.errorBody}
+${cameFrom}` : cameFrom,
+    exitCode: exitCodes.notFound
+  };
 }
 
 // src/core/interactiveRunner/runFiles.ts
@@ -33215,10 +35140,7 @@ async function handleRunnerExec(ctx, options, deps) {
     ...scope.files === undefined ? {} : { files: scope.files }
   }, runnerCallOptions);
   if (!result.ok) {
-    return {
-      ...failureFields(result),
-      exitCode: result.exitCode ?? exitCodes.network
-    };
+    return runnerRequestFailure(result, resolved);
   }
   if (result.value.outcome === "failure") {
     return describeEvaluateSnippetFailure(result.value);
@@ -33241,7 +35163,7 @@ async function handleRunnerExec(ctx, options, deps) {
 }
 
 // src/shell/interactiveRunner/collectRunFiles.ts
-import { join as join51 } from "node:path";
+import { join as join53 } from "node:path";
 
 // src/core/interactiveRunner/getImports.ts
 function getImports(options) {
@@ -33280,46 +35202,7 @@ function isPathAlias(importPath, paths) {
 }
 
 // src/core/interactiveRunner/resolveImportPath.ts
-import { dirname as dirname15, join as join50, normalize as normalize3 } from "node:path/posix";
-
-// src/core/interactiveRunner/tsconfigPaths.ts
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
-}
-function isTsconfigPaths(value) {
-  return isRecord4(value) && Object.values(value).every((targets) => Array.isArray(targets) && targets.every((target) => typeof target === "string"));
-}
-function parseTsconfigPaths(tsconfigContent) {
-  let parsed;
-  try {
-    parsed = JSON.parse(tsconfigContent);
-  } catch {
-    return;
-  }
-  if (!isRecord4(parsed))
-    return;
-  const compilerOptions = parsed["compilerOptions"];
-  if (!isRecord4(compilerOptions))
-    return;
-  const paths = compilerOptions["paths"];
-  return isTsconfigPaths(paths) ? paths : undefined;
-}
-function resolvePathAlias(importPath, paths) {
-  if (paths === undefined)
-    return;
-  for (const [pattern, targets] of Object.entries(paths)) {
-    const prefix = pattern.replace("*", "");
-    if (!importPath.startsWith(prefix))
-      continue;
-    const [target] = targets;
-    if (target !== undefined) {
-      return target.replace("*", importPath.slice(prefix.length));
-    }
-  }
-  return;
-}
-
-// src/core/interactiveRunner/resolveImportPath.ts
+import { dirname as dirname15, join as join52, normalize as normalize3 } from "node:path/posix";
 var supportedExtensions = [".ts", ".js"];
 function candidatesForExplicitExtension(options) {
   const matching = supportedExtensions.find((extension) => options.importPath.endsWith(extension));
@@ -33333,7 +35216,7 @@ function candidatesForExplicitExtension(options) {
 }
 function resolveImportPath(options) {
   const aliasTarget = resolvePathAlias(options.importPath, options.tsconfigPaths);
-  const resolvedPath = aliasTarget === undefined ? normalize3(join50(dirname15(options.importingFilePath), options.importPath)) : normalize3(aliasTarget);
+  const resolvedPath = aliasTarget === undefined ? normalize3(join52(dirname15(options.importingFilePath), options.importPath)) : normalize3(aliasTarget);
   const hasExplicitExtension = supportedExtensions.some((extension) => options.importPath.endsWith(extension));
   const candidates = hasExplicitExtension ? candidatesForExplicitExtension({
     importPath: options.importPath,
@@ -33357,7 +35240,7 @@ function resolveImportPath(options) {
 var tsconfigPath = "tsconfig.json";
 async function collectRunFiles(options) {
   const held = await listShippablePaths(options);
-  const readFile = (path) => options.fs.readFile(join51(options.cwd, path));
+  const readFile = (path) => options.fs.readFile(join53(options.cwd, path));
   const tsconfigContent = held.has(tsconfigPath) ? await readFile(tsconfigPath).catch(() => {
     return;
   }) : undefined;
@@ -33440,7 +35323,7 @@ function makeRunnerId() {
 }
 
 // src/shell/interactiveRunner/runFilesManifest.ts
-import { join as join52 } from "node:path";
+import { join as join54 } from "node:path";
 var manifestFileName = "runner-files.json";
 var manifestSchema2 = object({
   files: array(object({ contentHash: string2(), path: string2() })),
@@ -33448,75 +35331,37 @@ var manifestSchema2 = object({
   version: literal(1)
 });
 function makeRunFilesManifestStore(options) {
-  const directory = join52(options.cwd, qawolfDir);
-  const path = join52(directory, manifestFileName);
-  let pendingWrites = 0;
+  const directory = join54(options.cwd, qawolfDir);
+  const path = join54(directory, manifestFileName);
   return {
-    async read() {
-      const contents = await options.fs.readFile(path).catch(() => {
-        return;
-      });
-      if (contents === undefined)
-        return;
-      const parsed = manifestSchema2.safeParse(parseJson(contents));
-      return parsed.success ? parsed.data : undefined;
-    },
+    read: () => readJsonFile(options.fs, path, manifestSchema2),
     async write(manifest) {
-      const pendingPath = `${path}.${String(process.pid)}.${String(++pendingWrites)}.tmp`;
       await options.fs.mkdir(directory, { recursive: true });
-      await options.fs.writeFile(pendingPath, `${JSON.stringify(manifest, undefined, 2)}
-`);
-      await options.fs.rename(pendingPath, path);
+      await writeJsonFileAtomically(options.fs, path, manifest);
     }
   };
 }
-function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return;
-  }
-}
 
 // src/shell/interactiveRunner/runnerStore.ts
-import { join as join53 } from "node:path";
-var storeFileName = "runner.json";
+import { join as join55 } from "node:path";
+var storeFileName2 = "runner.json";
 var runnersDirName = "runners";
 var storedRunnerSchema = object({
   id: string2(),
   runnerName: string2().optional()
 });
-var storeSchema = object({
+var storeSchema2 = object({
   defaultRunnerId: string2().optional()
 });
-function parseJson2(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return;
-  }
-}
-var pendingWrites = 0;
 function makeRunnerStore(options) {
-  const directory = join53(options.cwd, qawolfDir);
-  const path = join53(directory, storeFileName);
-  const runnersDir = join53(directory, runnersDirName);
-  const nextPendingPath = (target) => `${target}.${process.pid}.${++pendingWrites}.tmp`;
-  const runnerPath = (runnerId) => join53(runnersDir, `${encodeURIComponent(runnerId)}.json`);
-  const writeAtomically = async (target, contents) => {
-    const pendingPath = nextPendingPath(target);
-    await options.fs.writeFile(pendingPath, `${JSON.stringify(contents, undefined, 2)}
-`);
-    await options.fs.rename(pendingPath, target);
-  };
+  const directory = join55(options.cwd, qawolfDir);
+  const path = join55(directory, storeFileName2);
+  const runnersDir = join55(directory, runnersDirName);
+  const runnerPath = (runnerId) => join55(runnersDir, `${encodeURIComponent(runnerId)}.json`);
+  const writeAtomically = (target, contents) => writeJsonFileAtomically(options.fs, target, contents);
   const readDefaultRunnerId = async () => {
-    const contents = await options.fs.readFile(path).catch(() => {
-      return;
-    });
-    if (contents === undefined)
-      return;
-    const parsed = storeSchema.safeParse(parseJson2(contents));
-    return parsed.success ? parsed.data.defaultRunnerId : undefined;
+    const stored = await readJsonFile(options.fs, path, storeSchema2);
+    return stored?.defaultRunnerId;
   };
   const writeDefaultRunnerId = async (runnerId) => {
     await options.fs.mkdir(directory, { recursive: true });
@@ -33538,15 +35383,7 @@ function makeRunnerStore(options) {
     },
     readDefaultRunnerId,
     async readRunners() {
-      const runners = await Promise.all((await readRunnerFileNames()).map(async (name) => {
-        const contents = await options.fs.readFile(join53(runnersDir, name)).catch(() => {
-          return;
-        });
-        if (contents === undefined)
-          return;
-        const parsed = storedRunnerSchema.safeParse(parseJson2(contents));
-        return parsed.success ? parsed.data : undefined;
-      }));
+      const runners = await Promise.all((await readRunnerFileNames()).map((name) => readJsonFile(options.fs, join55(runnersDir, name), storedRunnerSchema)));
       return runners.filter((runner) => !!runner).sort((left, right) => left.id.localeCompare(right.id));
     },
     async rememberLaunch(runner) {
@@ -33558,13 +35395,13 @@ function makeRunnerStore(options) {
       await Promise.all(runnerIds.map((runnerId) => options.fs.rm(runnerPath(runnerId), { force: true })));
       const names = await readRunnerFileNames();
       await Promise.all(names.map(async (name) => {
-        const runnerFile = join53(runnersDir, name);
+        const runnerFile = join55(runnersDir, name);
         const contents = await options.fs.readFile(runnerFile).catch(() => {
           return;
         });
         if (contents === undefined)
           return;
-        if (storedRunnerSchema.safeParse(parseJson2(contents)).success)
+        if (storedRunnerSchema.safeParse(parseJson(contents)).success)
           return;
         await options.fs.rm(runnerFile, { force: true });
       }));
@@ -33673,7 +35510,7 @@ async function handleRunnerHighlightSelector(ctx, options, deps) {
   const selector = options.selector ?? "";
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.highlightSelector, { id: resolved.runnerId, selector }, runnerCallOptions);
   if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
+    return runnerRequestFailure(result, resolved);
   }
   const { outcome } = result.value;
   switch (outcome) {
@@ -33736,7 +35573,7 @@ function registerRunnerHighlightSelectorCommand(runner, signals) {
 }
 
 // src/domains/interactiveRunner/importPackage.ts
-import { join as join54 } from "node:path";
+import { join as join56 } from "node:path";
 
 // src/core/interactiveRunner/npmDependencies.ts
 var sectionsInPrecedenceOrder = ["dependencies", "devDependencies"];
@@ -33777,7 +35614,7 @@ function readNpmDependencies(packageJsonContent) {
 // src/domains/interactiveRunner/importPackage.ts
 var defaultPackageVersion = "latest";
 async function handleRunnerImportPackage(ctx, options, deps) {
-  const content = await deps.readFile(join54(deps.cwd, runPackageJsonPath)).catch(() => {
+  const content = await deps.readFile(join56(deps.cwd, runPackageJsonPath)).catch(() => {
     return;
   });
   if (content === undefined) {
@@ -33809,10 +35646,7 @@ async function handleRunnerImportPackage(ctx, options, deps) {
     packageVersion
   }, runnerCallOptions);
   if (!result.ok) {
-    return {
-      ...failureFields(result),
-      exitCode: result.exitCode ?? exitCodes.network
-    };
+    return runnerRequestFailure(result, resolved);
   }
   if (result.value.outcome === "failure") {
     const failure = result.value;
@@ -33879,7 +35713,7 @@ async function handleRunnerInspect(ctx, options, deps) {
   }
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.inspect, { id: resolved.runnerId, request: built.request }, runnerCallOptions);
   if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
+    return runnerRequestFailure(result, resolved);
   }
   if (result.value.outcome === "failure") {
     const failure = result.value;
@@ -34014,7 +35848,7 @@ async function handleRunnerInspectMobile(ctx, options, deps) {
   }
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.inspectMobile, { id: resolved.runnerId, request: built.request }, runnerCallOptions);
   if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
+    return runnerRequestFailure(result, resolved);
   }
   if (result.value.outcome === "success") {
     const value = result.value;
@@ -34306,14 +36140,11 @@ async function handleRunnerAct(ctx, options, deps) {
     ...options.screenshot === undefined ? {} : { withScreenshot: true }
   }, runnerCallOptions);
   if (!result.ok) {
-    const fields = failureFields(result);
-    return {
+    const fields = runnerRequestFailure(result, resolved);
+    return result.mayHaveArrived ? {
       ...fields,
-      ...result.mayHaveArrived ? {
-        error: appendSentence(fields.error, interactiveRunnerMessages.actionMayHaveHappened)
-      } : {},
-      exitCode: exitCodes.network
-    };
+      error: appendSentence(fields.error, interactiveRunnerMessages.actionMayHaveHappened)
+    } : fields;
   }
   const answer = result.value;
   if (answer.outcome === "success") {
@@ -34358,9 +36189,8 @@ async function handleRunnerScreenshot(ctx, options, deps) {
     };
   }
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.takeScreenshot, { id: resolved.runnerId }, runnerCallOptions);
-  if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
-  }
+  if (!result.ok)
+    return runnerRequestFailure(result, resolved);
   if (result.value.outcome === "success") {
     const written = await deps.writeScreenshot({
       imageJpegBase64: result.value.imageJpegBase64,
@@ -34465,20 +36295,16 @@ var unreachableFailure = {
   error: interactiveRunnerMessages.runnerUnreachable,
   exitCode: exitCodes.network
 };
-async function readJournal(ctx, runnerId, request) {
+async function readJournal(ctx, runner, request) {
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.readJournal, {
-    id: runnerId,
+    id: runner.runnerId,
     stream: request.stream,
     ...request.runId === undefined ? {} : { runId: request.runId },
     ...request.sinceSequence === undefined ? {} : { sinceSequence: request.sinceSequence },
     ...request.tail === undefined ? {} : { tail: request.tail }
   }, runnerCallOptions);
   if (!result.ok) {
-    return {
-      ...failureFields(result),
-      exitCode: exitCodes.network,
-      type: "failed"
-    };
+    return { ...runnerRequestFailure(result, runner), type: "failed" };
   }
   if (result.value.outcome === "failure") {
     result.value.failureReason;
@@ -34493,7 +36319,7 @@ async function handleRunnerKeepalive(ctx, options, deps) {
   if (resolved.type === "failed") {
     return { ...failureFields(resolved), exitCode: resolved.exitCode };
   }
-  const window = await readJournal(ctx, resolved.runnerId, {
+  const window = await readJournal(ctx, resolved, {
     stream: "run-status",
     tail: 1
   });
@@ -34523,7 +36349,8 @@ async function handleRunnerLaunch(ctx, options, deps) {
   if (envRunnerId && envRunnerId !== launched.value.id) {
     ctx.ui.warn(interactiveRunnerMessages.envRunnerIdShadowsLaunch(launched.value.id, envRunnerId));
   }
-  ctx.ui.output(launched.value, launched.value.alreadyRunning ? interactiveRunnerMessages.alreadyRunning(launched.value.id) : interactiveRunnerMessages.launched(launched.value.id));
+  const runner = launched.value;
+  ctx.ui.output(runner, runner.alreadyRunning ? interactiveRunnerMessages.alreadyRunning(runner.id, runner.url) : interactiveRunnerMessages.launched(runner.id, runner.url));
   return;
 }
 
@@ -34561,7 +36388,8 @@ async function listRunners(ctx, deps) {
     id: runner.id,
     isDefault: runner.id === defaultRunnerId,
     launchedHere: heldIds.has(runner.id),
-    runnerName: runner.runnerName
+    runnerName: runner.runnerName,
+    url: runner.url
   }));
   return {
     items: items.sort((left, right) => rank(left) - rank(right) || left.id.localeCompare(right.id)),
@@ -34600,7 +36428,7 @@ async function handleRunnerStopRun(ctx, options, deps) {
   }
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.stopRun, { id: resolved.runnerId }, runnerCallOptions);
   if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
+    return runnerRequestFailure(result, resolved);
   }
   if (result.value.outcome === "failure") {
     result.value.failureReason;
@@ -34623,7 +36451,7 @@ async function handleRunnerTerminate(ctx, options, deps) {
     id: resolved.runnerId
   }, runnerCallOptions);
   if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
+    return runnerRequestFailure(result, resolved);
   }
   await deps.store.forgetRunner(resolved.runnerId).catch(() => {
     ctx.ui.warn(interactiveRunnerMessages.defaultNotForgotten(resolved.runnerId));
@@ -34671,7 +36499,7 @@ async function handleRunnerPromoteSnapshot(ctx, options, deps) {
     screenshotPath: options.screenshotPath
   }, runnerCallOptions);
   if (!result.ok) {
-    return { ...failureFields(result), exitCode: exitCodes.network };
+    return runnerRequestFailure(result, resolved);
   }
   if (result.value.outcome === "success") {
     ctx.ui.output(result.value, interactiveRunnerMessages.snapshotPromoted(options.screenshotPath, options.baselinePath));
@@ -34718,16 +36546,6 @@ function registerRunnerPromoteSnapshotCommand(runner, signals) {
 
 // src/core/interactiveRunner/followTimeout.ts
 var defaultFollowTimeoutSeconds = 3600;
-var followTimeoutSchema = exports_coerce.number().int().positive();
-function parseFollowTimeout(seconds) {
-  if (seconds === undefined) {
-    return { ok: true, seconds: defaultFollowTimeoutSeconds };
-  }
-  const parsed = followTimeoutSchema.safeParse(seconds);
-  if (!parsed.success)
-    return { error: prettifyError(parsed.error), ok: false };
-  return { ok: true, seconds: parsed.data };
-}
 
 // src/core/interactiveRunner/journal.ts
 function formatJournalLine(entry, options) {
@@ -34805,12 +36623,12 @@ function parseEventsOptions(options) {
 }
 
 // src/domains/interactiveRunner/journalCursor.ts
-function createJournalCursor(ctx, runnerId, request) {
+function createJournalCursor(ctx, runner, request) {
   let sinceSequence = request.sinceSequence;
   let tail = request.tail;
   let warnedUnsearchedHistory = false;
   return async function read() {
-    const window = await readJournal(ctx, runnerId, {
+    const window = await readJournal(ctx, runner, {
       ...request,
       sinceSequence,
       tail
@@ -34832,8 +36650,8 @@ function createJournalCursor(ctx, runnerId, request) {
     return { entries: window.value.entries, type: "entries" };
   };
 }
-function createPrintingCursor(ctx, runnerId, request, format) {
-  const read = createJournalCursor(ctx, runnerId, request);
+function createPrintingCursor(ctx, runner, request, format) {
+  const read = createJournalCursor(ctx, runner, request);
   return async () => {
     const window = await read();
     if (window.type !== "entries")
@@ -34857,12 +36675,12 @@ function createUnreachableBudget(pollIntervalMs) {
 }
 
 // src/domains/interactiveRunner/events.ts
-var pollIntervalMs2 = 1000;
+var pollIntervalMs3 = 1000;
 async function handleRunnerEvents(ctx, options, deps) {
   const parsed = parseEventsOptions(options);
   if (!parsed.ok)
     return { error: parsed.error, exitCode: exitCodes.invalidArgs };
-  const timeout = parseFollowTimeout(options.timeout);
+  const timeout = parseFollowTimeout(options.timeout, defaultFollowTimeoutSeconds);
   if (!timeout.ok) {
     return { error: timeout.error, exitCode: exitCodes.invalidArgs };
   }
@@ -34874,9 +36692,9 @@ async function handleRunnerEvents(ctx, options, deps) {
   if (!known.includes(parsed.value.stream)) {
     ctx.ui.warn(interactiveRunnerMessages.unknownStream(parsed.value.stream, known));
   }
-  const read = createJournalCursor(ctx, resolved.runnerId, parsed.value);
-  const unreachable = createUnreachableBudget(pollIntervalMs2);
-  const maxPolls = Math.max(1, Math.ceil(timeout.seconds * 1000 / pollIntervalMs2));
+  const read = createJournalCursor(ctx, resolved, parsed.value);
+  const unreachable = createUnreachableBudget(pollIntervalMs3);
+  const maxPolls = Math.max(1, Math.ceil(timeout.seconds * 1000 / pollIntervalMs3));
   for (let poll = 1;; poll++) {
     const window = await read();
     if (window.type === "failed")
@@ -34902,7 +36720,7 @@ async function handleRunnerEvents(ctx, options, deps) {
         exitCode: exitCodes.timeout
       };
     }
-    await deps.sleep(pollIntervalMs2);
+    await deps.sleep(pollIntervalMs3);
   }
 }
 
@@ -34930,12 +36748,12 @@ var anchorPollIntervalMs = 1000;
 async function resolveRecorderAnchor(ctx, resolved, deps) {
   if (resolved.type === "launched")
     return { ok: true, sinceSequence: 0 };
-  return anchorRecorderCursor(ctx, resolved.runnerId, deps);
+  return anchorRecorderCursor(ctx, resolved, deps);
 }
-async function anchorRecorderCursor(ctx, runnerId, deps) {
+async function anchorRecorderCursor(ctx, runner, deps) {
   const unreachable = createUnreachableBudget(anchorPollIntervalMs);
   for (;; ) {
-    const anchor = await readJournal(ctx, runnerId, {
+    const anchor = await readJournal(ctx, runner, {
       stream: "recorder",
       tail: 1
     });
@@ -34955,20 +36773,20 @@ function createFollowPrinters(ctx, options) {
   const jsonLine = (payload) => JSON.stringify(payload);
   const printers = [];
   if (options.logs) {
-    printers.push(createPrintingCursor(ctx, options.runnerId, { runId: options.runId, stream: "run-logs" }, formatRunLogLine));
+    printers.push(createPrintingCursor(ctx, options.runner, { runId: options.runId, stream: "run-logs" }, formatRunLogLine));
   }
   if (options.runEvents) {
-    printers.push(createPrintingCursor(ctx, options.runnerId, { runId: options.runId, stream: "run-events" }, jsonLine));
+    printers.push(createPrintingCursor(ctx, options.runner, { runId: options.runId, stream: "run-events" }, jsonLine));
   }
   if (options.recorderSinceSequence !== undefined) {
-    printers.push(createPrintingCursor(ctx, options.runnerId, { sinceSequence: options.recorderSinceSequence, stream: "recorder" }, jsonLine));
+    printers.push(createPrintingCursor(ctx, options.runner, { sinceSequence: options.recorderSinceSequence, stream: "recorder" }, jsonLine));
   }
   return printers;
 }
 
 // src/domains/interactiveRunner/followRun.ts
-var pollIntervalMs3 = 1000;
-function reportSettlement(ctx, settlement) {
+var pollIntervalMs4 = 1000;
+function reportSettlement2(ctx, settlement) {
   if (settlement.type === "passed") {
     ctx.ui.success(interactiveRunnerMessages.runPassed);
     return;
@@ -34980,11 +36798,11 @@ function reportSettlement(ctx, settlement) {
 }
 async function followRun(ctx, options, deps) {
   const printers = createFollowPrinters(ctx, options);
-  const readStatus = createJournalCursor(ctx, options.runnerId, {
+  const readStatus = createJournalCursor(ctx, options.runner, {
     runId: options.runId,
     stream: "run-status"
   });
-  const unreachable = createUnreachableBudget(pollIntervalMs3);
+  const unreachable = createUnreachableBudget(pollIntervalMs4);
   const printAll = async () => {
     for (const print of printers) {
       const window = await print();
@@ -35003,7 +36821,7 @@ async function followRun(ctx, options, deps) {
     progressReported = true;
     ctx.ui.stream(entry, interactiveRunnerMessages.runInProgress);
   };
-  const maxPolls = Math.max(1, Math.ceil(options.timeoutSeconds * 1000 / pollIntervalMs3));
+  const maxPolls = Math.max(1, Math.ceil(options.timeoutSeconds * 1000 / pollIntervalMs4));
   for (let poll = 1;; poll++) {
     const interrupted = await printAll();
     if (interrupted?.type === "failed")
@@ -35022,16 +36840,16 @@ async function followRun(ctx, options, deps) {
         if (await printAll() !== undefined) {
           ctx.ui.warn(interactiveRunnerMessages.followEndCutShort);
         }
-        return reportSettlement(ctx, settlement);
+        return reportSettlement2(ctx, settlement);
       }
     }
     if (poll >= maxPolls) {
       return {
-        error: interactiveRunnerMessages.followTimedOut(options.runId, options.runnerId, options.timeoutSeconds),
+        error: interactiveRunnerMessages.followTimedOut(options.runId, options.runner.runnerId, options.timeoutSeconds),
         exitCode: exitCodes.timeout
       };
     }
-    await deps.sleep(pollIntervalMs3);
+    await deps.sleep(pollIntervalMs4);
   }
 }
 
@@ -35235,10 +37053,7 @@ async function sendRunFlowRequest(ctx, options, delta) {
   }, runnerCallOptions);
   if (!result.ok) {
     return {
-      failure: {
-        ...failureFields(result),
-        exitCode: result.exitCode ?? exitCodes.network
-      },
+      failure: runnerRequestFailure(result, options.resolved),
       type: "failed"
     };
   }
@@ -35311,7 +37126,7 @@ async function finish(sent, fileSync, options, deps) {
 
 // src/domains/interactiveRunner/runFlow.ts
 async function handleRunnerRun(ctx, options, deps) {
-  const timeout = parseFollowTimeout(options.timeout);
+  const timeout = parseFollowTimeout(options.timeout, defaultFollowTimeoutSeconds);
   if (!timeout.ok) {
     return { error: timeout.error, exitCode: exitCodes.invalidArgs };
   }
@@ -35371,7 +37186,7 @@ async function handleRunnerRun(ctx, options, deps) {
     recorderSinceSequence,
     runEvents: options.runEvents,
     runId,
-    runnerId: resolved.runnerId,
+    runner: resolved,
     timeoutSeconds: timeout.seconds
   }, deps);
 }
@@ -35422,6 +37237,7 @@ function createProgram({
   const program = new Command2().name("qawolf").description("Run QA Wolf flows locally").version(package_default.version).option("--verbose", "Enable debug logging to stderr").option("--json", "Output as JSON").option("--agent", "Output for agent consumption").exitOverride((err) => {
     exit(err.exitCode === 0 ? exitCodes.success : exitCodes.invalidArgs);
   });
+  registerAgentCommand(program, signals);
   registerAuthCommand(program, signals);
   registerDoctorCommand(program, signals);
   registerFlowsCommand(program, signals);
@@ -35442,4 +37258,4 @@ createProgram({ signals }).parseAsync().catch(() => {
     process.exitCode = 1;
 }).finally(() => exitWhenIdle(typeof process.exitCode === "number" ? process.exitCode : 0));
 
-//# debugId=424C032AEE2722C964756E2164756E21
+//# debugId=59D2DE48FE68917864756E2164756E21