@qawolf/cli 1.29.0 → 1.30.0

package/dist/cli.js

@@ -8390,16 +8390,38 @@ function extractMissingPackage(text) {
   return specifier;
 }
 
-// src/core/pluralize.ts
-function pluralize(count, singular, plural = `${singular}s`) {
-  return `${String(count)} ${count === 1 ? singular : plural}`;
-}
-
 // src/core/formatSeconds.ts
 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: {
@@ -8669,7 +8691,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 +8866,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.`,
@@ -9237,8 +9260,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 +11906,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 +14501,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 +14723,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 +14732,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 +14753,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 +14768,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 +14781,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 +14806,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 +14828,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 +14835,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 +14864,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 +14890,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 +14906,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 +14975,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 +14997,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
   };
@@ -18988,7 +19081,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 +19359,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 +19372,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 +19380,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 +19410,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);
@@ -20142,6 +20237,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 +20871,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 +20931,7 @@ function createStyledClack() {
     cancel,
     confirm,
     password,
+    text,
     autocomplete,
     select,
     isCancel,
@@ -20873,6 +21035,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 +21057,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 +21141,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 +21220,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 +21318,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 +21341,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 +21466,7 @@ function startUpdateCheck(deps) {
 // package.json
 var package_default = {
   name: "@qawolf/cli",
-  version: "1.29.0",
+  version: "1.30.0",
   description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   keywords: [
     "automation",
@@ -21288,7 +21541,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,111 +21682,576 @@ 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
-          })
+  return {
+    error: session.status === "cancelled" ? agentMessages.sessionCancelled(session.url) : agentMessages.sessionFailed(session.url),
+    exitCode: exitCodes.testFailure
+  };
+}
+
+// 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;
+}
+async function answerQuestion(ctx, options) {
+  const answer = await ask(ctx, options.question);
+  if (answer === undefined) {
+    ctx.ui.warn(agentMessages.answerCancelled);
+    return { type: "declined" };
+  }
+  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"
+    };
+  }
+  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 (!v.valid)
-          throw Error(v.error);
       }
-    },
-    {
-      message: authMessages.storing,
-      task: async () => saveApiKey(ctx.configDir, apiKey, ctx.fs)
+      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
+        };
+      }
     }
-  ], ([, saveResult]) => {
-    return saveResult.stored === "file" ? authMessages.storedFile : authMessages.storedKeychain;
-  });
-  ctx.ui.outro(authMessages.outroSuccess);
+  } finally {
+    stopWaiting();
+    detach();
+  }
 }
 
-// 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/core/resolveId.ts
+async function resolveIdFrom(options) {
+  if (options.given !== undefined)
+    return options.given;
+  const fromEnvironment = options.env[options.environmentVariable]?.trim();
+  if (fromEnvironment)
+    return fromEnvironment;
+  return options.readStored();
 }
-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 };
+
+// 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 };
   }
-  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 { ok: true, sessionId: argument ?? flag };
+}
+var resolveSessionId = (session, deps) => resolveIdFrom({
+  env: deps.env,
+  environmentVariable: sessionIdEnvironmentVariable,
+  given: session,
+  readStored: deps.store.readLastSessionId
+});
+
+// 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
+      });
     }
-    case "error":
-      return { action: "fail", reason: "network", detail: response.detail };
   }
+  ctx.ui.output(session, agentMessages.standing(session.status, session.url));
 }
-
-// src/domains/auth/deviceLogin.ts
-var cancelled = {
-  ok: false,
-  reason: "cancelled",
-  detail: undefined
-};
-async function deviceLogin(deps) {
-  if (deps.isCancelled())
-    return cancelled;
-  const authorization = await deps.requestAuthorization();
-  if (!authorization.ok) {
-    return { ok: false, reason: "unavailable", detail: authorization.error };
+async function handleAgentGet(ctx, options, deps) {
+  const timeout = parseFollowTimeout(options.timeout, defaultAgentFollowTimeoutSeconds);
+  if (!timeout.ok) {
+    return { error: timeout.error, exitCode: exitCodes.invalidArgs };
   }
-  await deps.onPrompt(authorization.value);
-  let state = {
-    intervalMs: authorization.value.intervalSec * 1000,
-    deadlineMs: deps.now() + authorization.value.expiresInSec * 1000
-  };
+  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) {
+  if (deps.isCancelled())
+    return cancelled;
+  const authorization = await deps.requestAuthorization();
+  if (!authorization.ok) {
+    return { ok: false, reason: "unavailable", detail: authorization.error };
+  }
+  await deps.onPrompt(authorization.value);
+  let state = {
+    intervalMs: authorization.value.intervalSec * 1000,
+    deadlineMs: deps.now() + authorization.value.expiresInSec * 1000
+  };
   for (;; ) {
     if (deps.isCancelled())
       return cancelled;
@@ -21841,10 +22559,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 +22767,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 +22779,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 +22789,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 +22838,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))
   };
 }
@@ -22203,92 +22919,947 @@ async function handleWhoami(ctx, deps = {}) {
     } else {
       ctx.ui.output({ authenticated: false, source: undefined }, authMessages.notAuthenticated);
     }
-    return { error: "not authenticated", exitCode: exitCodes.auth };
+    return { error: "not authenticated", exitCode: exitCodes.auth };
+  }
+  const platformClient = (deps.createPlatform ?? createPlatformClient)(resolved.key, {
+    baseUrl: ctx.apiBaseUrl,
+    fetch: globalThis.fetch,
+    logger: ctx.log("trpc")
+  });
+  const identity = await platformClient.getIdentity();
+  if (!identity.ok) {
+    if (ctx.ui.mode === "human") {
+      ctx.ui.note(authMessages.whoami.source(resolved.source), authMessages.whoamiFailed);
+      ctx.ui.warn(identity.error);
+    } else {
+      ctx.ui.output({
+        authenticated: false,
+        error: identity.error,
+        source: resolved.source,
+        valid: false
+      }, authMessages.whoami.authFailed(resolved.source, identity.error));
+    }
+    return {
+      error: "invalid key",
+      ...identity.exitCode === undefined ? {} : { exitCode: identity.exitCode }
+    };
+  }
+  const { value } = identity;
+  if ("user" in value) {
+    const { organization, user } = value;
+    const found = value.organizations.flatMap((candidate) => candidate.workspaces.map((workspace) => ({
+      organization: candidate.name,
+      workspace: workspace.name,
+      id: workspace.id
+    }))).find((entry) => entry.id === resolved.workspaceId);
+    const activeWorkspace = resolved.workspaceId ? authMessages.whoami.activeWorkspace(resolved.workspaceId, found) : undefined;
+    if (ctx.ui.mode === "human") {
+      ctx.ui.note(authMessages.whoami.userNote({
+        organization,
+        source: resolved.source,
+        user,
+        activeWorkspace,
+        organizations: value.organizations
+      }), authMessages.whoamiAuthenticated);
+      ctx.ui.outro(authMessages.outroReady);
+    } else {
+      ctx.ui.output({
+        authenticated: true,
+        organization,
+        source: resolved.source,
+        user,
+        workspaceId: resolved.workspaceId,
+        organizations: value.organizations
+      }, authMessages.whoami.authenticatedAs(user.email, resolved.source));
+    }
+    return;
+  }
+  if ("organization" in value) {
+    const { organization } = value;
+    if (ctx.ui.mode === "human") {
+      ctx.ui.note(authMessages.whoami.organizationNote({
+        organization,
+        source: resolved.source
+      }), authMessages.whoamiAuthenticated);
+      ctx.ui.outro(authMessages.outroReady);
+    } else {
+      ctx.ui.output({
+        authenticated: true,
+        organization,
+        source: resolved.source
+      }, authMessages.whoami.authenticatedAs(organization.name, resolved.source));
+    }
+    return;
+  }
+  reportTeamIdentity(ctx, value, resolved.source);
+}
+
+// src/commands/auth/index.ts
+function registerAuthCommand(program, signals) {
+  const auth = program.command("auth").description("Manage authentication with QA Wolf");
+  declareCommandKind(auth.command("login"), "local").description("Authenticate with QA Wolf in a browser or with an API key").action(withContext(signals, handleLogin));
+  declareCommandKind(auth.command("logout"), "local").description("Remove stored credentials").action(withContext(signals, handleLogout));
+  declareCommandKind(auth.command("switch"), "local").description("Choose which workspace to work in").action(withContext(signals, handleSwitchWorkspace));
+  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}`);
+    }
   }
-  const platformClient = (deps.createPlatform ?? createPlatformClient)(resolved.key, {
-    baseUrl: ctx.apiBaseUrl,
-    fetch: globalThis.fetch,
-    logger: ctx.log("trpc")
-  });
-  const identity = await platformClient.getIdentity();
-  if (!identity.ok) {
-    if (ctx.ui.mode === "human") {
-      ctx.ui.note(authMessages.whoami.source(resolved.source), authMessages.whoamiFailed);
-      ctx.ui.warn(identity.error);
-    } else {
-      ctx.ui.output({
-        authenticated: false,
-        error: identity.error,
-        source: resolved.source,
-        valid: false
-      }, authMessages.whoami.authFailed(resolved.source, identity.error));
+});
+
+// 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 {
-      error: "invalid key",
-      ...identity.exitCode === undefined ? {} : { exitCode: identity.exitCode }
+      ...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)
+      }
+    });
   }
-  const { value } = identity;
-  if ("user" in value) {
-    const { organization, user } = value;
-    const found = value.organizations.flatMap((candidate) => candidate.workspaces.map((workspace) => ({
-      organization: candidate.name,
-      workspace: workspace.name,
-      id: workspace.id
-    }))).find((entry) => entry.id === resolved.workspaceId);
-    const activeWorkspace = resolved.workspaceId ? authMessages.whoami.activeWorkspace(resolved.workspaceId, found) : undefined;
-    if (ctx.ui.mode === "human") {
-      ctx.ui.note(authMessages.whoami.userNote({
-        organization,
-        source: resolved.source,
-        user,
-        activeWorkspace,
-        organizations: value.organizations
-      }), authMessages.whoamiAuthenticated);
-      ctx.ui.outro(authMessages.outroReady);
-    } else {
-      ctx.ui.output({
-        authenticated: true,
-        organization,
-        source: resolved.source,
-        user,
-        workspaceId: resolved.workspaceId,
-        organizations: value.organizations
-      }, authMessages.whoami.authenticatedAs(user.email, resolved.source));
-    }
-    return;
-  }
-  if ("organization" in value) {
-    const { organization } = value;
-    if (ctx.ui.mode === "human") {
-      ctx.ui.note(authMessages.whoami.organizationNote({
-        organization,
-        source: resolved.source
-      }), authMessages.whoamiAuthenticated);
-      ctx.ui.outro(authMessages.outroReady);
+});
+
+// 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 {
-      ctx.ui.output({
-        authenticated: true,
-        organization,
-        source: resolved.source
-      }, authMessages.whoami.authenticatedAs(organization.name, resolved.source));
+      const browserInfo = getWebBrowserInfo(value.meta);
+      meta = {
+        defaultBrowser: browserInfo,
+        gpuEnabled: value.meta.gpuEnabled,
+        kind: "browser"
+      };
     }
-    return;
+    return {
+      ...value,
+      meta,
+      runnerName
+    };
+  },
+  encode(value) {
+    return webTargetInputSchema.parse(value);
   }
-  reportTeamIdentity(ctx, value, resolved.source);
-}
+});
 
-// src/commands/auth/index.ts
-function registerAuthCommand(program, signals) {
-  const auth = program.command("auth").description("Manage authentication with QA Wolf");
-  declareCommandKind(auth.command("login"), "local").description("Authenticate with QA Wolf in a browser or with an API key").action(withContext(signals, handleLogin));
-  declareCommandKind(auth.command("logout"), "local").description("Remove stored credentials").action(withContext(signals, handleLogout));
-  declareCommandKind(auth.command("switch"), "local").description("Choose which workspace to work in").action(withContext(signals, handleSwitchWorkspace));
-  declareCommandKind(auth.command("whoami"), "read").description("Show authentication status").action(withContext(signals, handleWhoami));
-}
+// 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 +23904,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 +23965,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 +24276,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 +24292,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 +24428,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 +24458,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 +25287,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 +25402,7 @@ var browserNameToPlaywright = {
 function classifyTarget(target) {
   let parsed;
   try {
-    parsed = parseExecutionTarget2(target);
+    parsed = parseExecutionTarget(target);
   } catch {
     return { kind: "unrecognized" };
   }
@@ -23876,11 +25446,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 +25476,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 +25511,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 +25545,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 +25578,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 +25629,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 +25664,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 +25701,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 +25714,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 +25751,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 +25945,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 +25971,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 +26005,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 +26031,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 +26044,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 +26436,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 +26458,7 @@ async function fetchBundleAndEnvVars(ctx, envId) {
   let bundleFetchedAt;
   let envVars;
   let envVarsFetchedAt;
+  let teamId;
   let tags;
   await ctx.ui.withProgress([
     {
@@ -24903,10 +26474,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 +26489,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 +26589,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 +26604,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 +26617,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 +26641,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 +26665,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 +26678,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 +26718,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 +26746,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 +26811,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
   });
 }
@@ -28674,8 +30253,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 +30300,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)
@@ -29101,9 +30681,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 +30706,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 +31127,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 join40, 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 +31157,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 +31172,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 +31190,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 +31223,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 +31251,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 +31280,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 +31289,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 +31303,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 +31327,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 +31345,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) {
@@ -29779,14 +31356,14 @@ async function installOuterDeps(runDir, deps, fs, install) {
 
 // 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 join39, 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 join38 } 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(join38(source, entry.name), join38(destination, entry.name), {
     recursive: true,
     filter: (path) => !excludedNames.has(basename5(path))
   })));
@@ -29803,14 +31380,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, join39(execDir, basename6(f)))));
+  return files.map((f) => join39(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 = join39(execDir, dirHash);
   await fs.mkdir(subDir, { recursive: true });
-  const dest = join38(subDir, basename6(file));
+  const dest = join39(subDir, basename6(file));
   await fs.copyFile(file, dest);
   return dest;
 }
@@ -29818,7 +31395,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 join39(execDir, file.slice(projectDir.length + 1));
   }
   return;
 }
@@ -29828,10 +31405,10 @@ 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 = join40(runRoot, runId);
   await fs.rm(runDir, { recursive: true, force: true });
   await fs.mkdir(runDir, { recursive: true });
-  const execDir = join39(runDir, "exec");
+  const execDir = join40(runDir, "exec");
   await fs.mkdir(execDir, { recursive: true });
   await populateInnerHop({ depsRoot, execDir, fs });
   const stagedFiles = await stageFlowFiles({ files, projectDir, execDir, fs });
@@ -29862,17 +31439,17 @@ function buildRunId(projectDir, files) {
 }
 
 // src/shell/testkit.ts
-import { join as join40 } from "node:path";
+import { join as join41 } 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 = join41(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(join41(testkitDir, "dist", "clientScope.js"));
     if (typeof scopeMod.configureTestkitClient !== "function")
       throw new Error("configureTestkitClient is not a function");
     return {
@@ -29930,9 +31507,9 @@ async function registerLazyEmailsClient(getInbox, cwd, deps) {
 }
 
 // src/commands/flows/envVarDeps.ts
-import { join as join41 } from "node:path";
+import { join as join42 } from "node:path";
 function envFilePath(envDir) {
-  return join41(envDir, ".env");
+  return join42(envDir, ".env");
 }
 async function readEnv(envDir, fs) {
   try {
@@ -30056,7 +31633,7 @@ async function selectRunByTag(args) {
 }
 
 // src/commands/flows/runStagedFlows.ts
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 
 // src/shell/appium/createAppiumServer.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -30190,7 +31767,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 +31785,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 +32939,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 join43 } 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 = join43(getDataDir(), "worker");
+  const dest = join43(dir, basename7(assetPath));
   if (existsSync3(dest))
     return dest;
   mkdirSync3(dir, { recursive: true });
@@ -31527,33 +33104,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 +33141,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 +33150,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 +33170,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 join44 } from "node:path";
 
 // src/shell/reporter/junitXml.ts
 function escapeXml(str) {
@@ -31646,7 +33223,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 : join44(outputDir, "junit-report.xml");
 }
 function createJUnitReporter(deps) {
   const flows = [];
@@ -31737,11 +33314,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 join45 } from "node:path";
 async function loadEnvFile(envDir) {
   let content;
   try {
-    content = await readFile(join44(envDir, ".env"), "utf8");
+    content = await readFile(join45(envDir, ".env"), "utf8");
   } catch (err) {
     if (isNoEntError(err))
       return;
@@ -31786,7 +33363,7 @@ async function runStagedFlows(args) {
     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 : join46(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 +33459,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 join47, resolve as resolve10 } from "node:path";
 
 // src/core/selectFlowFiles.ts
 function selectFlowFiles(args) {
@@ -31987,7 +33564,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(join47(".qawolf", flags.env));
   const patternArgs = buildPatternArgs(pattern);
   const globFlows = () => resolvedDeps.expandPatterns(patternArgs, envDir, ctx.log("flows"));
   let files = await globFlows();
@@ -32183,12 +33760,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 join49, relative as relative9 } from "node:path";
 
 // src/domains/init/ensurePackageJson.ts
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 async function ensurePackageJson(ctx, yes, deps) {
-  const pkgPath = join47(deps.cwd, "package.json");
+  const pkgPath = join48(deps.cwd, "package.json");
   if (!await deps.fs.pathExists(pkgPath)) {
     const confirmed = await ctx.ui.confirm(initMessages.createPackageJsonPrompt, { yes });
     if (!confirmed.ok || !confirmed.value) {
@@ -32314,9 +33891,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 = join49(deps.cwd, "qawolf.config.ts");
+  const flowPath = join49(deps.cwd, "src", "flows", "example.flow.ts");
+  const gitignorePath = join49(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 +33927,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 join50 } 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 +33938,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 = join50(deps.androidHome, "licenses", "android-sdk-license");
   if (deps.checkExists(licenseFile)) {
     ctx.ui.info(installMessages.android.licensesAlreadyAccepted);
   } else {
@@ -32379,7 +33953,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 = join50(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 +34066,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;
@@ -32881,6 +34455,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 +34475,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,14 +34611,12 @@ 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) {
@@ -33096,11 +34642,15 @@ async function resolveRunner(ctx, options, deps) {
       type: "failed"
     };
   }
-  return { runnerId: launched.value.id, type: "launched" };
+  return {
+    runnerId: launched.value.id,
+    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));
   }
 }
 
@@ -33241,7 +34791,7 @@ async function handleRunnerExec(ctx, options, deps) {
 }
 
 // src/shell/interactiveRunner/collectRunFiles.ts
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 
 // src/core/interactiveRunner/getImports.ts
 function getImports(options) {
@@ -33280,7 +34830,7 @@ function isPathAlias(importPath, paths) {
 }
 
 // src/core/interactiveRunner/resolveImportPath.ts
-import { dirname as dirname15, join as join50, normalize as normalize3 } from "node:path/posix";
+import { dirname as dirname15, join as join51, normalize as normalize3 } from "node:path/posix";
 
 // src/core/interactiveRunner/tsconfigPaths.ts
 function isRecord4(value) {
@@ -33333,7 +34883,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(join51(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 +34907,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(join52(options.cwd, path));
   const tsconfigContent = held.has(tsconfigPath) ? await readFile(tsconfigPath).catch(() => {
     return;
   }) : undefined;
@@ -33440,7 +34990,7 @@ function makeRunnerId() {
 }
 
 // src/shell/interactiveRunner/runFilesManifest.ts
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 var manifestFileName = "runner-files.json";
 var manifestSchema2 = object({
   files: array(object({ contentHash: string2(), path: string2() })),
@@ -33448,75 +34998,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 = join53(options.cwd, qawolfDir);
+  const path = join53(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 join54 } 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 = join54(options.cwd, qawolfDir);
+  const path = join54(directory, storeFileName2);
+  const runnersDir = join54(directory, runnersDirName);
+  const runnerPath = (runnerId) => join54(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 +35050,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, join54(runnersDir, name), storedRunnerSchema)));
       return runners.filter((runner) => !!runner).sort((left, right) => left.id.localeCompare(right.id));
     },
     async rememberLaunch(runner) {
@@ -33558,13 +35062,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 = join54(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 });
       }));
@@ -33736,7 +35240,7 @@ function registerRunnerHighlightSelectorCommand(runner, signals) {
 }
 
 // src/domains/interactiveRunner/importPackage.ts
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 
 // src/core/interactiveRunner/npmDependencies.ts
 var sectionsInPrecedenceOrder = ["dependencies", "devDependencies"];
@@ -33777,7 +35281,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(join55(deps.cwd, runPackageJsonPath)).catch(() => {
     return;
   });
   if (content === undefined) {
@@ -34523,7 +36027,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 +36066,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)),
@@ -34718,16 +36224,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) {
@@ -34857,12 +36353,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 };
   }
@@ -34875,8 +36371,8 @@ async function handleRunnerEvents(ctx, options, deps) {
     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 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 +36398,7 @@ async function handleRunnerEvents(ctx, options, deps) {
         exitCode: exitCodes.timeout
       };
     }
-    await deps.sleep(pollIntervalMs2);
+    await deps.sleep(pollIntervalMs3);
   }
 }
 
@@ -34967,8 +36463,8 @@ function createFollowPrinters(ctx, options) {
 }
 
 // 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;
@@ -34984,7 +36480,7 @@ async function followRun(ctx, options, deps) {
     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 +36499,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,7 +36518,7 @@ 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) {
@@ -35031,7 +36527,7 @@ async function followRun(ctx, options, deps) {
         exitCode: exitCodes.timeout
       };
     }
-    await deps.sleep(pollIntervalMs3);
+    await deps.sleep(pollIntervalMs4);
   }
 }
 
@@ -35311,7 +36807,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 };
   }
@@ -35422,6 +36918,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 +36939,4 @@ createProgram({ signals }).parseAsync().catch(() => {
     process.exitCode = 1;
 }).finally(() => exitWhenIdle(typeof process.exitCode === "number" ? process.exitCode : 0));
 
-//# debugId=424C032AEE2722C964756E2164756E21
+//# debugId=65A771FAB553A0D964756E2164756E21