@yoqa/runner 0.3.24 → 0.3.25

package/dist/index.js

@@ -16513,7 +16513,8 @@ var runTests = sqliteTable("run_tests", {
   executionMode: text("execution_mode"),
   error: text("error"),
   startedAt: integer("started_at"),
-  finishedAt: integer("finished_at")
+  finishedAt: integer("finished_at"),
+  currentCommand: text("current_command")
 });
 var runSteps = sqliteTable("run_steps", {
   id: text("id").primaryKey(),
@@ -16524,6 +16525,7 @@ var runSteps = sqliteTable("run_steps", {
   ok: integer("ok").notNull().default(0),
   latencyMs: integer("latency_ms").notNull().default(0),
   detail: text("detail"),
+  command: text("command"),
   createdAt: integer("created_at").notNull()
 });
 
@@ -16638,7 +16640,8 @@ function ensureSchema(sqlite) {
 			execution_mode TEXT,
 			error TEXT,
 			started_at INTEGER,
-			finished_at INTEGER
+			finished_at INTEGER,
+			current_command TEXT
 		);
 
 		CREATE TABLE IF NOT EXISTS run_steps (
@@ -16650,6 +16653,7 @@ function ensureSchema(sqlite) {
 			ok INTEGER NOT NULL DEFAULT 0,
 			latency_ms INTEGER NOT NULL DEFAULT 0,
 			detail TEXT,
+			command TEXT,
 			created_at INTEGER NOT NULL
 		);
 
@@ -16668,6 +16672,7 @@ function ensureSchema(sqlite) {
   migrateAppsPrefix(sqlite);
   migrateCaseScripts(sqlite);
   migrateRunExecutionMode(sqlite);
+  migrateRunCommands(sqlite);
 }
 function tableColumns(sqlite, table) {
   const rows = sqlite.query(`PRAGMA table_info(${table})`).all();
@@ -16696,6 +16701,16 @@ function migrateRunExecutionMode(sqlite) {
     addColumnIfMissing(sqlite, "run_tests", "execution_mode", "execution_mode TEXT", testCols);
   }
 }
+function migrateRunCommands(sqlite) {
+  const testCols = tableColumns(sqlite, "run_tests");
+  if (testCols.size > 0) {
+    addColumnIfMissing(sqlite, "run_tests", "current_command", "current_command TEXT", testCols);
+  }
+  const stepCols = tableColumns(sqlite, "run_steps");
+  if (stepCols.size > 0) {
+    addColumnIfMissing(sqlite, "run_steps", "command", "command TEXT", stepCols);
+  }
+}
 function migrateProvidersTable(sqlite) {
   const existing = tableColumns(sqlite, "providers");
   if (existing.size === 0)
@@ -16801,7 +16816,7 @@ function getCatalogDb() {
 // package.json
 var package_default = {
   name: "@yoqa/runner",
-  version: "0.3.24",
+  version: "0.3.25",
   description: "Yoqa local runner \u2014 Appium + catalog HTTP API (Bun). Start with yoqa serve or the yoqa-runner bin.",
   license: "UNLICENSED",
   type: "module",
@@ -16884,12 +16899,14 @@ function trackMjpegProxy() {
   return controller;
 }
 function abortAllMjpegProxies() {
+  const had = proxies.size > 0;
   for (const controller of [...proxies]) {
     try {
       controller.abort();
     } catch {}
   }
   proxies.clear();
+  return had;
 }
 
 // src/domains/devices/session.ts
@@ -17597,6 +17614,7 @@ function isDeadSessionError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return DEAD_SESSION_RE.test(message);
 }
+var DEAD_SESSION_RETRY_MS = 200;
 function mjpegSettingsForDevice(options) {
   const physicalIos = options.platform === "ios" && looksLikePhysicalIosUdid(options.deviceId);
   if (physicalIos) {
@@ -17981,10 +17999,17 @@ async function createDeviceSession(options) {
     try {
       return await fn();
     } catch (error) {
-      if (isDeadSessionError(error)) {
-        notifySessionDead();
+      if (!isDeadSessionError(error))
+        throw error;
+      await Bun.sleep(DEAD_SESSION_RETRY_MS);
+      try {
+        return await fn();
+      } catch (retryError) {
+        if (isDeadSessionError(retryError)) {
+          notifySessionDead();
+        }
+        throw retryError;
       }
-      throw error;
     }
   };
   const getWindowSize = async () => guard(() => browser.getWindowSize());
@@ -18048,10 +18073,10 @@ async function createDeviceSession(options) {
       });
     });
   };
-  const swipe = async (x1, y1, x2, y2, durationMs = 400) => {
+  const swipe = async (x1, y1, x2, y2, durationMs = 400, swipeOptions) => {
     await gate.withLock(async () => {
       await guard(async () => {
-        const size = await getPointerSize();
+        const size = swipeOptions?.coordSpace === "screenshot" ? await getScreenshotCoordSize() : await getPointerSize();
         await injectSwipe(browser, toPx(x1, size.width), toPx(y1, size.height), toPx(x2, size.width), toPx(y2, size.height), durationMs);
       });
     });
@@ -24263,6 +24288,8 @@ var caseScriptTapSchema = exports_external.object({
   y: exports_external.number().min(0).max(1000).optional(),
   label: exports_external.string().min(1).optional(),
   id: exports_external.string().min(1).optional(),
+  double: exports_external.boolean().optional(),
+  durationMs: exports_external.number().min(50).max(5000).optional(),
   reason: exports_external.string().optional()
 }).superRefine((value, ctx) => {
   const hasCoords = value.x != null && value.y != null;
@@ -24273,8 +24300,45 @@ var caseScriptTapSchema = exports_external.object({
     });
   }
 });
+var caseScriptSwipeSchema = exports_external.object({
+  type: exports_external.literal("swipe"),
+  x: exports_external.number().min(0).max(1000),
+  y: exports_external.number().min(0).max(1000),
+  x2: exports_external.number().min(0).max(1000),
+  y2: exports_external.number().min(0).max(1000),
+  durationMs: exports_external.number().min(50).max(5000).optional(),
+  reason: exports_external.string().optional()
+});
+var caseScriptDragSchema = exports_external.object({
+  type: exports_external.literal("drag"),
+  x: exports_external.number().min(0).max(1000),
+  y: exports_external.number().min(0).max(1000),
+  x2: exports_external.number().min(0).max(1000),
+  y2: exports_external.number().min(0).max(1000),
+  durationMs: exports_external.number().min(50).max(5000).optional(),
+  reason: exports_external.string().optional()
+});
+var caseScriptAppIdSchema = exports_external.union([
+  exports_external.object({
+    type: exports_external.literal("activate-app"),
+    appId: exports_external.string().min(1),
+    reason: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("terminate-app"),
+    appId: exports_external.string().min(1),
+    reason: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("restart-app"),
+    appId: exports_external.string().min(1),
+    reason: exports_external.string().optional()
+  })
+]);
 var caseScriptActionSchema = exports_external.union([
   caseScriptTapSchema,
+  caseScriptSwipeSchema,
+  caseScriptDragSchema,
   exports_external.object({
     type: exports_external.literal("type"),
     text: exports_external.string(),
@@ -24296,6 +24360,17 @@ var caseScriptActionSchema = exports_external.union([
     type: exports_external.literal("alert"),
     alertAction: exports_external.union([exports_external.literal("accept"), exports_external.literal("dismiss")]).default("accept"),
     reason: exports_external.string().optional()
+  }),
+  caseScriptAppIdSchema,
+  exports_external.object({
+    type: exports_external.literal("background-app"),
+    seconds: exports_external.number().min(0).max(120).optional(),
+    reason: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("open-url"),
+    url: exports_external.string().min(1),
+    reason: exports_external.string().optional()
   })
 ]);
 var caseScriptSchema = exports_external.object({
@@ -24552,6 +24627,7 @@ var runStepSchema = exports_external.object({
   ok: exports_external.boolean(),
   latencyMs: exports_external.number().nonnegative(),
   detail: exports_external.string().nullable(),
+  command: exports_external.string().nullable().optional(),
   createdAt: exports_external.number().int().nonnegative()
 });
 var runTestSchema = exports_external.object({
@@ -24563,6 +24639,7 @@ var runTestSchema = exports_external.object({
   error: exports_external.string().nullable(),
   startedAt: exports_external.number().int().nonnegative().nullable(),
   finishedAt: exports_external.number().int().nonnegative().nullable(),
+  currentCommand: exports_external.string().nullable().optional(),
   steps: exports_external.array(runStepSchema).optional()
 });
 var runSchema = exports_external.object({
@@ -24736,6 +24813,59 @@ function decodeXmlEntities(value) {
 }
 
 // ../../packages/runner-client/src/shell-script.ts
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatActionShellLine(action) {
+  const parts = ["yoqa", "action", action.kind];
+  if (action.id) {
+    parts.push("--id", shellSingleQuote(action.id));
+  }
+  if (action.label) {
+    parts.push("--label", shellSingleQuote(action.label));
+  }
+  if (action.description) {
+    parts.push("-d", shellSingleQuote(action.description));
+  }
+  if (action.x != null)
+    parts.push("--x", String(Math.round(action.x)));
+  if (action.y != null)
+    parts.push("--y", String(Math.round(action.y)));
+  if (action.x2 != null)
+    parts.push("--x2", String(Math.round(action.x2)));
+  if (action.y2 != null)
+    parts.push("--y2", String(Math.round(action.y2)));
+  if (action.durationMs != null)
+    parts.push("--duration", String(Math.round(action.durationMs)));
+  if (action.double)
+    parts.push("--double");
+  if (action.text != null)
+    parts.push("--text", shellSingleQuote(action.text));
+  if (action.appId != null)
+    parts.push("--app-id", shellSingleQuote(action.appId));
+  if (action.url != null)
+    parts.push("--url", shellSingleQuote(action.url));
+  if (action.seconds != null)
+    parts.push("--seconds", String(action.seconds));
+  if (action.kind === "alert") {
+    if (action.alertAction === "dismiss")
+      parts.push("--dismiss");
+  }
+  return parts.join(" ");
+}
+function formatSleepShellLine(seconds) {
+  const safe = Math.max(0, seconds);
+  const rounded = Number.isInteger(safe) ? String(safe) : String(Number(safe.toFixed(3)));
+  return `sleep ${rounded}`;
+}
+function formatAssertShellLine(input) {
+  const parts = ["yoqa", "assert", input.assertion, "--text", shellSingleQuote(input.text.trim())];
+  const timeout = input.timeoutSeconds ?? 5;
+  if (timeout !== 5) {
+    parts.push("--timeout", String(timeout));
+  }
+  return parts.join(" ");
+}
 var DEFAULT_SHELL_SCRIPT_HEADER = [
   "#!/usr/bin/env bash",
   "# Yoqa inspector script",
@@ -25163,9 +25293,16 @@ function normalizeVisionJson(value) {
     out.x = clampNormCoord(out.x);
   if (typeof out.y === "number")
     out.y = clampNormCoord(out.y);
+  if (typeof out.x2 === "number")
+    out.x2 = clampNormCoord(out.x2);
+  if (typeof out.y2 === "number")
+    out.y2 = clampNormCoord(out.y2);
   if (typeof out.ms === "number" && Number.isFinite(out.ms)) {
     out.ms = Math.min(1e4, Math.max(0, out.ms));
   }
+  if (typeof out.durationMs === "number" && Number.isFinite(out.durationMs)) {
+    out.durationMs = Math.min(5000, Math.max(50, Math.round(out.durationMs)));
+  }
   const reason = typeof out.reason === "string" ? out.reason.trim() : "";
   const thoughts = typeof out.thoughts === "string" ? out.thoughts.trim() : "";
   if (reason)
@@ -96053,26 +96190,257 @@ async function completeVision(auth, input) {
 }
 
 // src/domains/runs/agent.ts
+var swipeDirectionSchema = exports_external.union([
+  exports_external.literal("up"),
+  exports_external.literal("down"),
+  exports_external.literal("left"),
+  exports_external.literal("right")
+]);
 var agentDecisionSchema = exports_external.object({
   type: exports_external.union([
     exports_external.literal("tap"),
+    exports_external.literal("swipe"),
+    exports_external.literal("drag"),
     exports_external.literal("type"),
+    exports_external.literal("input"),
     exports_external.literal("wait"),
     exports_external.literal("alert"),
+    exports_external.literal("activate-app"),
+    exports_external.literal("terminate-app"),
+    exports_external.literal("restart-app"),
+    exports_external.literal("background-app"),
+    exports_external.literal("open-url"),
+    exports_external.literal("assert"),
     exports_external.literal("verify"),
     exports_external.literal("done"),
     exports_external.literal("fail")
   ]),
   x: exports_external.number().optional(),
   y: exports_external.number().optional(),
+  x2: exports_external.number().optional(),
+  y2: exports_external.number().optional(),
+  direction: swipeDirectionSchema.optional(),
+  durationMs: exports_external.number().optional(),
+  double: exports_external.boolean().optional(),
   label: exports_external.string().min(1).optional(),
   id: exports_external.string().min(1).optional(),
+  description: exports_external.string().min(1).optional(),
   text: exports_external.string().optional(),
   ms: exports_external.number().optional(),
   alertAction: exports_external.union([exports_external.literal("accept"), exports_external.literal("dismiss")]).optional(),
+  appId: exports_external.string().min(1).optional(),
+  url: exports_external.string().min(1).optional(),
+  seconds: exports_external.number().optional(),
+  assertion: exports_external.union([exports_external.literal("visible"), exports_external.literal("not-visible")]).optional(),
+  timeoutMs: exports_external.number().optional(),
   reason: exports_external.string().min(1),
   thoughts: exports_external.string().min(1)
+}).superRefine((value, ctx) => {
+  if (value.type === "swipe") {
+    const hasCoords = value.x != null && value.y != null && value.x2 != null && value.y2 != null;
+    if (!hasCoords && value.direction == null) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: "swipe requires direction or x,y,x2,y2"
+      });
+    }
+  }
+  if (value.type === "drag") {
+    if (value.x == null || value.y == null || value.x2 == null || value.y2 == null) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: "drag requires x,y,x2,y2"
+      });
+    }
+  }
+  if ((value.type === "type" || value.type === "input") && !value.text?.trim()) {
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, message: "type/input requires text" });
+  }
+  if (value.type === "open-url" && !value.url?.trim()) {
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, message: "open-url requires url" });
+  }
+  if (value.type === "assert" && !value.text?.trim()) {
+    ctx.addIssue({ code: exports_external.ZodIssueCode.custom, message: "assert requires text" });
+  }
 });
+var FINGER_SWIPE_NORMS = {
+  up: { x: 500, y: 800, x2: 500, y2: 200 },
+  down: { x: 500, y: 200, x2: 500, y2: 800 },
+  left: { x: 800, y: 500, x2: 200, y2: 500 },
+  right: { x: 200, y: 500, x2: 800, y2: 500 }
+};
+function resolveSwipeNorm(decision) {
+  if (decision.x != null && decision.y != null && decision.x2 != null && decision.y2 != null) {
+    return { x: decision.x, y: decision.y, x2: decision.x2, y2: decision.y2 };
+  }
+  if (decision.direction)
+    return FINGER_SWIPE_NORMS[decision.direction];
+  return null;
+}
+var MAX_SCREEN_SNAPSHOT_ROWS = 80;
+function padNorm(n) {
+  return String(Math.round(n)).padStart(4, " ");
+}
+function formatScreenSnapshot(elements) {
+  if (elements == null)
+    return "(screen tree unavailable)";
+  if (elements.length === 0)
+    return "(empty tree)";
+  const ordered = [...elements].sort((a, b) => a.y - b.y || a.x - b.x);
+  const shown = ordered.slice(0, MAX_SCREEN_SNAPSHOT_ROWS);
+  const lines = shown.map((element) => {
+    const id = element.id?.trim() ? ` id=${element.id.trim()}` : "";
+    const label = element.label?.trim() || "(no label)";
+    return `${padNorm(element.x)},${padNorm(element.y)}  ${Math.round(element.width)}x${Math.round(element.height)}${id}  ${label}`;
+  });
+  if (ordered.length > shown.length) {
+    lines.push(`\u2026 ${ordered.length - shown.length} more elements omitted`);
+  }
+  return lines.join(`
+`);
+}
+function decisionToActionRequest(decision, options = {}) {
+  const appId = decision.appId?.trim() || options.defaultAppId?.trim() || undefined;
+  switch (decision.type) {
+    case "tap": {
+      const body = { kind: "tap" };
+      if (decision.double)
+        body.double = true;
+      if (decision.durationMs != null)
+        body.durationMs = decision.durationMs;
+      if (decision.description)
+        body.description = decision.description;
+      if (prefersScreenshotTap(decision)) {
+        body.x = decision.x;
+        body.y = decision.y;
+      } else if (decision.id) {
+        body.id = decision.id;
+        if (decision.label)
+          body.label = decision.label;
+      } else if (decision.label) {
+        body.label = decision.label;
+      } else if (decision.description) {} else {
+        body.x = decision.x ?? 500;
+        body.y = decision.y ?? 500;
+      }
+      return body;
+    }
+    case "swipe": {
+      const swipe = resolveSwipeNorm(decision);
+      if (!swipe)
+        return null;
+      return {
+        kind: "swipe",
+        x: swipe.x,
+        y: swipe.y,
+        x2: swipe.x2,
+        y2: swipe.y2,
+        ...decision.durationMs != null ? { durationMs: decision.durationMs } : {}
+      };
+    }
+    case "drag":
+      if (decision.x == null || decision.y == null || decision.x2 == null || decision.y2 == null) {
+        return null;
+      }
+      return {
+        kind: "drag",
+        x: decision.x,
+        y: decision.y,
+        x2: decision.x2,
+        y2: decision.y2,
+        ...decision.durationMs != null ? { durationMs: decision.durationMs } : {}
+      };
+    case "type":
+    case "input": {
+      const body = { kind: "input", text: decision.text ?? "" };
+      if (decision.id)
+        body.id = decision.id;
+      if (decision.label)
+        body.label = decision.label;
+      if (decision.x != null)
+        body.x = decision.x;
+      if (decision.y != null)
+        body.y = decision.y;
+      if (decision.description)
+        body.description = decision.description;
+      return body;
+    }
+    case "alert":
+      return {
+        kind: "alert",
+        alertAction: decision.alertAction === "dismiss" ? "dismiss" : "accept"
+      };
+    case "activate-app":
+      return appId ? { kind: "activate-app", appId } : null;
+    case "terminate-app":
+      return appId ? { kind: "terminate-app", appId } : null;
+    case "restart-app":
+      return appId ? { kind: "restart-app", appId } : null;
+    case "background-app":
+      return {
+        kind: "background-app",
+        ...decision.seconds != null ? { seconds: decision.seconds } : {}
+      };
+    case "open-url":
+      return decision.url ? { kind: "open-url", url: decision.url } : null;
+    default:
+      return null;
+  }
+}
+var SCROLL_INTENT_RE = /\b(scroll|swipe|flick)\b/i;
+var SCROLL_UP_RE = /\b(scroll\s+up|back\s+up|to the top|content above)\b/i;
+var SCROLL_UNTIL_END_RE = /\b(scroll[\s\w]{0,48}(bottom|end)|cannot scroll|can not scroll|can't scroll|until you can'?t scroll|no longer scroll|not be able to scroll)\b/i;
+function looksLikeScrollIntent(text3) {
+  return SCROLL_INTENT_RE.test(text3);
+}
+function isScrollUntilEndGoal(instructions, expectedResult) {
+  return SCROLL_UNTIL_END_RE.test(`${instructions} ${expectedResult}`);
+}
+function inferFingerDirection(text3) {
+  if (SCROLL_UP_RE.test(text3))
+    return "down";
+  if (/\bscroll\s+left\b/i.test(text3) || /\bswipe\s+left\b/i.test(text3))
+    return "left";
+  if (/\bscroll\s+right\b/i.test(text3) || /\bswipe\s+right\b/i.test(text3))
+    return "right";
+  return "up";
+}
+function asDirectionalSwipe(decision) {
+  const text3 = `${decision.reason} ${decision.thoughts}`;
+  return {
+    type: "swipe",
+    direction: inferFingerDirection(text3),
+    reason: decision.reason,
+    thoughts: decision.thoughts
+  };
+}
+function coerceScrollIntentToSwipe(decision) {
+  if (decision.type === "tap" && isSystemPermissionLabel(decision.label))
+    return decision;
+  if (decision.type !== "tap" && decision.type !== "wait")
+    return decision;
+  if (!looksLikeScrollIntent(`${decision.reason} ${decision.thoughts}`))
+    return decision;
+  return asDirectionalSwipe(decision);
+}
+function continueScrollingInsteadOfComplete(input) {
+  if (input.decision.type !== "verify" && input.decision.type !== "done") {
+    return input.decision;
+  }
+  const hadSwipe = input.recentActions.some((action) => action.type === "swipe");
+  const untilEnd = isScrollUntilEndGoal(input.instructions, input.expectedResult);
+  const claimedScroll = looksLikeScrollIntent(`${input.decision.reason} ${input.decision.thoughts}`);
+  if (!hadSwipe && (untilEnd || claimedScroll)) {
+    return asDirectionalSwipe(input.decision);
+  }
+  if (untilEnd && hadSwipe && input.lastSwipeMovedScreen) {
+    return asDirectionalSwipe(input.decision);
+  }
+  return input.decision;
+}
+function screenshotFingerprint(base643) {
+  return String(Bun.hash(base643));
+}
 var SYSTEM_PERMISSION_LABELS = new Set([
   "allow",
   "don't allow",
@@ -96092,7 +96460,11 @@ function isSystemPermissionLabel(label) {
   return SYSTEM_PERMISSION_LABELS.has(trimmed);
 }
 function prefersScreenshotTap(decision) {
-  return decision.x != null && decision.y != null && !isSystemPermissionLabel(decision.label);
+  if (isSystemPermissionLabel(decision.label))
+    return false;
+  if (decision.id?.trim())
+    return false;
+  return decision.x != null && decision.y != null;
 }
 var SYSTEM_PROMPT = `You are a mobile QA agent controlling an app via screenshots.
 A screenshot of the current device screen is ALWAYS attached to the user message as an image. You can see it. Never claim that no screenshot was provided, missing, blank, or unavailable.
@@ -96106,20 +96478,51 @@ Valid shapes:
 {"type":"tap","label":"Allow","reason":"...","thoughts":"..."}
 {"type":"tap","id":"permission_allow_button","reason":"...","thoughts":"..."}
 {"type":"tap","x":0-1000,"y":0-1000,"reason":"...","thoughts":"..."}
+{"type":"tap","description":"the blue Login button","reason":"...","thoughts":"..."}
+{"type":"tap","x":0-1000,"y":0-1000,"double":true,"reason":"...","thoughts":"..."}
+{"type":"tap","x":0-1000,"y":0-1000,"durationMs":2000,"reason":"...","thoughts":"..."}
+{"type":"swipe","direction":"up|down|left|right","reason":"...","thoughts":"..."}
+{"type":"swipe","x":0-1000,"y":0-1000,"x2":0-1000,"y2":0-1000,"reason":"...","thoughts":"..."}
+{"type":"drag","x":0-1000,"y":0-1000,"x2":0-1000,"y2":0-1000,"reason":"...","thoughts":"..."}
+{"type":"type","text":"...","x":0-1000,"y":0-1000,"reason":"...","thoughts":"..."}
+{"type":"input","text":"...","id":"email_field","reason":"...","thoughts":"..."}
 {"type":"alert","alertAction":"accept","reason":"...","thoughts":"..."}
-{"type":"type","text":"...","reason":"...","thoughts":"..."}
+{"type":"activate-app","appId":"com.example.app","reason":"...","thoughts":"..."}
+{"type":"terminate-app","appId":"com.example.app","reason":"...","thoughts":"..."}
+{"type":"restart-app","appId":"com.example.app","reason":"...","thoughts":"..."}
+{"type":"background-app","seconds":3,"reason":"...","thoughts":"..."}
+{"type":"open-url","url":"https://example.com","reason":"...","thoughts":"..."}
+{"type":"assert","assertion":"visible|not-visible","text":"...","reason":"...","thoughts":"..."}
 {"type":"wait","ms":500-3000,"reason":"...","thoughts":"..."}
 {"type":"verify","reason":"...","thoughts":"..."}
 {"type":"done","reason":"...","thoughts":"..."}
 {"type":"fail","reason":"...","thoughts":"..."}
 
-Coordinates use a 0\u20131000 normalized grid (0,0 top-left of the attached screenshot). For in-app controls, tap using screenshot x,y from what you see \u2014 do not prefer label or id over those coordinates.
+Coordinates use a 0\u20131000 normalized grid (0,0 top-left of the attached screenshot). The user message also includes a screen snapshot (cleaned accessibility tree) with the same grid \u2014 x,y is each element's TOP-LEFT, not centre. Centre = x + width/2, y + height/2.
+
+Use BOTH the screenshot and the screen snapshot:
+- Prefer snapshot "id=\u2026" when present (same as yoqa action tap --id).
+- System permission / notification dialogs: {"type":"tap","label":"Allow"} or {"type":"alert","alertAction":"accept"}. Never guess coordinates for these.
+- For other in-app controls, tap screenshot x,y of the visible control if there is no id.
+- If the snapshot is empty or the control is only drawn (no label/id), use the screenshot.
+- If a previous action failed (see Last action error), pick a different target from the snapshot + screenshot \u2014 do not repeat the same id/label/point.
+
+Swipe direction is the FINGER movement (same as Inspector):
+- "down" (finger down, y 200\u2192800): scroll UP \u2014 reveal content above
+- "up" (finger up, y 800\u2192200): scroll DOWN \u2014 reveal content below / to the bottom
+- "left" / "right": horizontal paging
+When the case says "scroll up", emit direction "down". When it says "scroll down" or "to the bottom", emit direction "up". Never tap to scroll. Never emit wait as a stand-in for scrolling.
 
 Rules:
-- Look at the attached screenshot before deciding. Base taps on what is visible now.
-- For ordinary app UI, emit {"type":"tap","x":\u2026,"y":\u2026} using the screenshot grid. Include label or id only for system permission / notification dialogs.
-- System permission / notification dialogs (Allow, Don't allow, While using the app): use {"type":"tap","label":"Allow"} or {"type":"alert","alertAction":"accept"}. Never guess coordinates for these buttons \u2014 coordinate taps often miss.
-- If the expected result (or the goal of the instructions) is already visible, return verify or done \u2014 do not keep tapping the same control.
+- Look at the attached screenshot AND the screen snapshot before deciding.
+- Double-tap: {"type":"tap","double":true,...}. Long-press: {"type":"tap","durationMs":2000,...}. Drag a slider/chip with type drag, not swipe.
+- activate-app / terminate-app / restart-app / open-url / background-app match yoqa action. Omit appId to use the catalog app id provided in the user message.
+- Assert text on the tree with {"type":"assert","assertion":"visible","text":"\u2026"}.
+- To scroll a list or page, emit swipe \u2014 never a tap in the middle of the screen as a stand-in for scrolling.
+- "Scroll until you cannot scroll anymore" / "to the bottom": keep emitting swipe (direction "up") until a later screenshot shows the same content. Then verify. Unchanged screens after taps do not count \u2014 taps do not scroll.
+- You are given ONE current instruction. Complete only that instruction, then return verify or done. Later instructions are hidden on purpose \u2014 do not invent, skip ahead, or combine them.
+- Do not open unrelated tabs or screens (Wallet, Profile, \u2026) unless the current instruction says to. If the current target is not visible, scroll THIS screen to find it. If it cannot be found, fail with what you see.
+- When THIS instruction's expected result is visible (or the action is done and the UI has updated), return verify or done. That finishes this instruction only, not the whole case.
 - Splash / loading / blank screens: return wait (do not tap imaginary tabs).
 - Do not repeat the same tap target from Recent actions unless the screenshot still shows you are on the wrong screen.
 - On fail, say what you see (e.g. "splash logo only, no bottom tabs") \u2014 never "no screenshot".`;
@@ -96137,12 +96540,30 @@ function formatRecentActions(actions) {
       }
       return `${n}. tap (${action.x ?? "?"},${action.y ?? "?"}) \u2014 ${action.reason ?? ""}`;
     }
+    if (action.type === "swipe") {
+      if (action.direction) {
+        return `${n}. swipe ${action.direction} \u2014 ${action.reason ?? ""}`;
+      }
+      return `${n}. swipe (${action.x ?? "?"},${action.y ?? "?"})\u2192(${action.x2 ?? "?"},${action.y2 ?? "?"}) \u2014 ${action.reason ?? ""}`;
+    }
     if (action.type === "alert") {
       return `${n}. alert ${action.alertAction ?? "accept"} \u2014 ${action.reason ?? ""}`;
     }
-    if (action.type === "type") {
+    if (action.type === "type" || action.type === "input") {
       return `${n}. type "${action.text ?? ""}" \u2014 ${action.reason ?? ""}`;
     }
+    if (action.type === "drag") {
+      return `${n}. drag (${action.x ?? "?"},${action.y ?? "?"})\u2192(${action.x2 ?? "?"},${action.y2 ?? "?"}) \u2014 ${action.reason ?? ""}`;
+    }
+    if (action.type === "assert") {
+      return `${n}. assert ${action.assertion ?? "visible"} "${action.text ?? ""}" \u2014 ${action.reason ?? ""}`;
+    }
+    if (action.type === "activate-app" || action.type === "terminate-app" || action.type === "restart-app") {
+      return `${n}. ${action.type} ${action.appId ?? ""} \u2014 ${action.reason ?? ""}`;
+    }
+    if (action.type === "open-url") {
+      return `${n}. open-url ${action.url ?? ""} \u2014 ${action.reason ?? ""}`;
+    }
     if (action.type === "wait") {
       return `${n}. wait ${action.ms ?? "?"}ms \u2014 ${action.reason ?? ""}`;
     }
@@ -96150,29 +96571,101 @@ function formatRecentActions(actions) {
   }).join(`
 `);
 }
-function isAbsurdNoScreenshotFail(decision) {
-  if (decision.type !== "fail")
-    return false;
-  const text3 = `${decision.reason} ${decision.thoughts}`.toLowerCase();
-  return text3.includes("no screenshot") || text3.includes("screenshot provided") || text3.includes("screenshot was not") || text3.includes("without a screenshot") || text3.includes("missing screenshot") || text3.includes("screenshot unavailable") || text3.includes("cannot see the screen") || text3.includes("no image");
+var LIST_ITEM_START_RE = /^(?:\d+[.)]|\d+\s*[-\u2013]|[-*\u2022])\s+/;
+function splitInstructionSteps(instructions) {
+  const trimmed = instructions.replace(/\r\n/g, `
+`).trim();
+  if (!trimmed)
+    return [""];
+  const lines = trimmed.split(`
+`);
+  const items = [];
+  let current = [];
+  let sawList = false;
+  const pushCurrent = () => {
+    const text3 = current.join(" ").replace(/\s+/g, " ").trim();
+    if (text3)
+      items.push(text3);
+    current = [];
+  };
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    if (LIST_ITEM_START_RE.test(line)) {
+      sawList = true;
+      pushCurrent();
+      current = [line.replace(LIST_ITEM_START_RE, "").trim()];
+    } else if (current.length > 0) {
+      current.push(line);
+    } else {
+      current = [line];
+    }
+  }
+  pushCurrent();
+  if (!sawList)
+    return [trimmed];
+  return items.length > 0 ? items : [trimmed];
+}
+function flattenCaseInstructions(flows2) {
+  const queue = [];
+  for (const flow of flows2) {
+    const steps = splitInstructionSteps(flow.instructions);
+    const usable = steps.length > 0 ? steps : [""];
+    for (let i = 0;i < usable.length; i++) {
+      const last = i === usable.length - 1;
+      queue.push({
+        instructions: usable[i] ?? "",
+        expectedResult: last ? flow.expectedResult : ""
+      });
+    }
+  }
+  return queue.length > 0 ? queue : [{ instructions: "", expectedResult: "" }];
 }
-async function decideNextAction(input) {
-  const prompt = [
+function formatCompletedInstructions(completed) {
+  if (completed.length === 0)
+    return "(none \u2014 this is the first instruction)";
+  return completed.map((text3, index) => `${index + 1}. ${text3}`).join(`
+`);
+}
+function formatDecidePrompt(input) {
+  const ordinal = input.instructionOrdinal ?? input.stepIndex + 1;
+  const total = input.instructionCount ?? 0;
+  const remaining = total > 0 ? Math.max(0, total - ordinal) : 0;
+  const expected = input.expectedResult.trim() ? input.expectedResult : "(none for this instruction \u2014 return verify once you have performed it and the UI has updated)";
+  const progress = total > 0 ? `Instruction ${ordinal} of ${total} \u2014 do ONLY this instruction${remaining > 0 ? `; ${remaining} remain after it` : " (last instruction)"}` : `Step ${input.stepIndex + 1}`;
+  const later = remaining > 0 ? `Later instructions exist (${remaining}) but are hidden. Do not invent or perform them. Do not open unrelated screens to skip ahead.` : "This is the last instruction of the case.";
+  return [
     `App context: ${input.appContext || "(none)"}`,
     `Test case: ${input.caseTitle}`,
-    `Step ${input.stepIndex + 1}`,
-    `Instructions: ${input.instructions || "(none)"}`,
-    `Expected result: ${input.expectedResult || "(none)"}`,
+    progress,
+    "Completed instructions (already done \u2014 do not repeat):",
+    formatCompletedInstructions(input.completedInstructions ?? []),
+    `Current instruction (do ONLY this): ${input.instructions || "(none)"}`,
+    `Expected result for this instruction: ${expected}`,
+    later,
+    `Catalog app id (activate/terminate/restart): ${input.defaultAppId || "(unknown)"}`,
     `Recent actions:
 ${formatRecentActions(input.recentActions ?? [])}`,
-    "Look at the attached screenshot image and decide the next action. A screenshot is attached.",
+    `Last action error: ${input.lastError || "(none)"}`,
+    "Screen snapshot (cleaned accessibility tree, 0\u20131000 grid, x,y is top-left):",
+    input.screenSnapshot || "(unavailable)",
+    "Look at the attached screenshot image AND the screen snapshot and decide the next action. A screenshot is attached.",
     'Reply with ONLY the JSON action object, including non-empty "reason" and "thoughts".'
   ].join(`
 `);
+}
+function isAbsurdNoScreenshotFail(decision) {
+  if (decision.type !== "fail")
+    return false;
+  const text3 = `${decision.reason} ${decision.thoughts}`.toLowerCase();
+  return text3.includes("no screenshot") || text3.includes("screenshot provided") || text3.includes("screenshot was not") || text3.includes("without a screenshot") || text3.includes("missing screenshot") || text3.includes("screenshot unavailable") || text3.includes("cannot see the screen") || text3.includes("no image");
+}
+async function decideNextAction(input) {
   return completeVision(input.auth, {
     schema: agentDecisionSchema,
     system: SYSTEM_PROMPT,
-    prompt,
+    prompt: formatDecidePrompt(input),
     imageBase64: input.imageBase64
   });
 }
@@ -96187,18 +96680,24 @@ function buildScriptFromDecisions(decisions, sourceRunId) {
           type: "tap",
           x: decision.x,
           y: decision.y,
+          ...decision.double ? { double: true } : {},
+          ...decision.durationMs != null ? { durationMs: decision.durationMs } : {},
           reason: decision.reason
         });
       } else if (decision.label) {
         actions.push({
           type: "tap",
           label: decision.label,
+          ...decision.double ? { double: true } : {},
+          ...decision.durationMs != null ? { durationMs: decision.durationMs } : {},
           reason: decision.reason
         });
       } else if (decision.id) {
         actions.push({
           type: "tap",
           id: decision.id,
+          ...decision.double ? { double: true } : {},
+          ...decision.durationMs != null ? { durationMs: decision.durationMs } : {},
           reason: decision.reason
         });
       } else {
@@ -96209,12 +96708,70 @@ function buildScriptFromDecisions(decisions, sourceRunId) {
           reason: decision.reason
         });
       }
-    } else if (decision.type === "type") {
+    } else if (decision.type === "swipe") {
+      const swipe = resolveSwipeNorm(decision);
+      if (!swipe)
+        continue;
+      actions.push({
+        type: "swipe",
+        x: swipe.x,
+        y: swipe.y,
+        x2: swipe.x2,
+        y2: swipe.y2,
+        ...decision.durationMs != null ? { durationMs: decision.durationMs } : {},
+        reason: decision.reason
+      });
+    } else if (decision.type === "type" || decision.type === "input") {
       actions.push({
         type: "type",
         text: decision.text ?? "",
         reason: decision.reason
       });
+    } else if (decision.type === "drag") {
+      if (decision.x == null || decision.y == null || decision.x2 == null || decision.y2 == null) {
+        continue;
+      }
+      actions.push({
+        type: "drag",
+        x: decision.x,
+        y: decision.y,
+        x2: decision.x2,
+        y2: decision.y2,
+        ...decision.durationMs != null ? { durationMs: decision.durationMs } : {},
+        reason: decision.reason
+      });
+    } else if (decision.type === "activate-app" || decision.type === "terminate-app" || decision.type === "restart-app") {
+      if (!decision.appId)
+        continue;
+      actions.push({
+        type: decision.type,
+        appId: decision.appId,
+        reason: decision.reason
+      });
+    } else if (decision.type === "background-app") {
+      actions.push({
+        type: "background-app",
+        ...decision.seconds != null ? { seconds: decision.seconds } : {},
+        reason: decision.reason
+      });
+    } else if (decision.type === "open-url") {
+      if (!decision.url)
+        continue;
+      actions.push({
+        type: "open-url",
+        url: decision.url,
+        reason: decision.reason
+      });
+    } else if (decision.type === "assert") {
+      if (!decision.text?.trim())
+        continue;
+      actions.push({
+        type: "assert",
+        assertion: decision.assertion === "not-visible" ? "not-visible" : "visible",
+        text: decision.text,
+        ...decision.timeoutMs != null ? { timeoutMs: decision.timeoutMs } : {},
+        reason: decision.reason
+      });
     } else if (decision.type === "wait") {
       actions.push({
         type: "wait",
@@ -98096,8 +98653,8 @@ ${treeSummary || "(none)"}`;
 }
 
 // src/domains/devices/interaction.ts
-async function getScreen(session, options = {}) {
-  abortAllMjpegProxies();
+var MJPEG_PAUSE_SETTLE_MS = 150;
+async function readScreen(session, options) {
   const raw2 = await session.pageSource();
   const window2 = await session.getWindowSize();
   if (options.full) {
@@ -98110,6 +98667,14 @@ async function getScreen(session, options = {}) {
     elements: cleaned.elements
   };
 }
+async function getScreen(session, options = {}) {
+  if (options.pauseMjpeg !== false) {
+    const paused = abortAllMjpegProxies();
+    if (paused)
+      await Bun.sleep(MJPEG_PAUSE_SETTLE_MS);
+  }
+  return await readScreen(session, options);
+}
 
 class ActionValidationError extends Error {
   constructor(message) {
@@ -98164,7 +98729,9 @@ async function performAction(session, body) {
         throw new ActionValidationError(`${body.kind} requires x,y,x2,y2`);
       }
       if (body.kind === "swipe") {
-        await session.swipe(x, y, body.x2, body.y2, body.durationMs);
+        await session.swipe(x, y, body.x2, body.y2, body.durationMs, {
+          coordSpace: "screenshot"
+        });
       } else {
         await session.drag(x, y, body.x2, body.y2, body.durationMs);
       }
@@ -98232,14 +98799,77 @@ var defaultClock = {
   sleep: (ms) => new Promise((resolve7) => setTimeout(resolve7, ms)),
   now: () => Date.now()
 };
+var noopSetCurrentCommand = async () => {};
+async function withCurrentCommand(setCurrentCommand, command, work) {
+  await setCurrentCommand(command);
+  try {
+    return await work();
+  } finally {
+    await setCurrentCommand(null);
+  }
+}
+function isRetriableActionError(error40) {
+  return error40 instanceof ActionNotFoundError || error40 instanceof ActionValidationError;
+}
+async function readCleanedTree(readScreen2, session) {
+  try {
+    const screen = await readScreen2(session);
+    const elements = screen.elements ?? [];
+    return { snapshot: formatScreenSnapshot(elements), elements };
+  } catch (error40) {
+    if (isDeadSessionError(error40))
+      throw error40;
+    const message = error40 instanceof Error ? error40.message : String(error40);
+    return { snapshot: `(screen tree unavailable: ${message})`, elements: [] };
+  }
+}
+async function runTextAssert(input) {
+  const deadline = input.clock.now() + input.timeoutMs;
+  for (;; ) {
+    if (input.isAborted()) {
+      throw new Error("Aborted");
+    }
+    const screen = await input.readScreen(input.session);
+    const found = screenHasText(screen.elements, input.text);
+    if (input.assertion === "visible" && found)
+      return;
+    if (input.assertion === "not-visible" && !found)
+      return;
+    if (input.clock.now() >= deadline) {
+      throw new Error(input.assertion === "visible" ? `Expected visible text not found within ${Math.round(input.timeoutMs / 1000)}s: ${input.text}` : `Unexpected text still visible after ${Math.round(input.timeoutMs / 1000)}s: ${input.text}`);
+    }
+    await input.clock.sleep(400);
+  }
+}
+function commandForDecision(decision, defaultAppId) {
+  if (decision.type === "verify" || decision.type === "done" || decision.type === "fail") {
+    return null;
+  }
+  if (decision.type === "wait") {
+    const waitMs = Math.min(3000, Math.max(500, decision.ms ?? 1500));
+    return formatSleepShellLine(waitMs / 1000);
+  }
+  if (decision.type === "assert") {
+    const assertion = decision.assertion === "not-visible" ? "not-visible" : "visible";
+    const timeoutMs = Math.min(60000, Math.max(1000, decision.timeoutMs ?? 5000));
+    return formatAssertShellLine({
+      assertion,
+      text: decision.text ?? "",
+      timeoutSeconds: timeoutMs / 1000
+    });
+  }
+  const body = decisionToActionRequest(decision, { defaultAppId });
+  return body ? formatActionShellLine(body) : null;
+}
 async function executeScriptCase(deps) {
   const perform = deps.performAction ?? performAction;
-  const readScreen = deps.readScreen ?? (async (session) => {
+  const readScreen2 = deps.readScreen ?? (async (session) => {
     const screen = await getScreen(session, { full: false });
     return { elements: screen.elements };
   });
   const clock = deps.clock ?? defaultClock;
   const settleMs = deps.settleMs ?? POST_ACTION_SETTLE_MS;
+  const setCurrentCommand = deps.setCurrentCommand ?? noopSetCurrentCommand;
   let stepIdx = 0;
   let lastScreenshotUri = null;
   try {
@@ -98264,108 +98894,274 @@ async function executeScriptCase(deps) {
           tapBody.x = action.x;
         if (action.y != null)
           tapBody.y = action.y;
-        await perform(deps.session, tapBody);
-        await clock.sleep(settleMs);
-        await deps.appendStep({
-          idx: stepIdx,
-          action: {
-            type: "tap",
-            x: action.x,
-            y: action.y,
-            label: action.label,
-            id: action.id,
-            reason: action.reason ?? "Replayed saved script tap",
-            thoughts: "Replaying the saved script without calling the AI agent."
-          },
-          screenshotUri: shot.path,
-          ok: true,
-          latencyMs,
-          detail: action.reason ?? action.label ?? action.id ?? null
+        if (action.double)
+          tapBody.double = true;
+        if (action.durationMs != null)
+          tapBody.durationMs = action.durationMs;
+        const command = formatActionShellLine(tapBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, tapBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "tap",
+              x: action.x,
+              y: action.y,
+              label: action.label,
+              id: action.id,
+              reason: action.reason ?? "Replayed saved script tap",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? action.label ?? action.id ?? null,
+            command
+          });
+        });
+      } else if (action.type === "swipe") {
+        const swipeBody = {
+          kind: "swipe",
+          x: action.x,
+          y: action.y,
+          x2: action.x2,
+          y2: action.y2,
+          ...action.durationMs != null ? { durationMs: action.durationMs } : {}
+        };
+        const command = formatActionShellLine(swipeBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, swipeBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "swipe",
+              x: action.x,
+              y: action.y,
+              x2: action.x2,
+              y2: action.y2,
+              durationMs: action.durationMs,
+              reason: action.reason ?? "Replayed saved script swipe",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? null,
+            command
+          });
+        });
+      } else if (action.type === "drag") {
+        const dragBody = {
+          kind: "drag",
+          x: action.x,
+          y: action.y,
+          x2: action.x2,
+          y2: action.y2,
+          ...action.durationMs != null ? { durationMs: action.durationMs } : {}
+        };
+        const command = formatActionShellLine(dragBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, dragBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "drag",
+              x: action.x,
+              y: action.y,
+              x2: action.x2,
+              y2: action.y2,
+              durationMs: action.durationMs,
+              reason: action.reason ?? "Replayed saved script drag",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? null,
+            command
+          });
+        });
+      } else if (action.type === "activate-app" || action.type === "terminate-app" || action.type === "restart-app") {
+        const appBody = { kind: action.type, appId: action.appId };
+        const command = formatActionShellLine(appBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, appBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: action.type,
+              appId: action.appId,
+              reason: action.reason ?? `Replayed saved script ${action.type}`,
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? action.appId,
+            command
+          });
+        });
+      } else if (action.type === "background-app") {
+        const backgroundBody = {
+          kind: "background-app",
+          ...action.seconds != null ? { seconds: action.seconds } : {}
+        };
+        const command = formatActionShellLine(backgroundBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, backgroundBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "background-app",
+              seconds: action.seconds,
+              reason: action.reason ?? "Replayed saved script background-app",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? null,
+            command
+          });
+        });
+      } else if (action.type === "open-url") {
+        const urlBody = { kind: "open-url", url: action.url };
+        const command = formatActionShellLine(urlBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, urlBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "open-url",
+              url: action.url,
+              reason: action.reason ?? "Replayed saved script open-url",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? action.url,
+            command
+          });
         });
       } else if (action.type === "type") {
-        await perform(deps.session, { kind: "input", text: action.text });
-        await clock.sleep(settleMs);
-        await deps.appendStep({
-          idx: stepIdx,
-          action: {
-            type: "type",
-            text: action.text,
-            reason: action.reason ?? "Replayed saved script type",
-            thoughts: "Replaying the saved script without calling the AI agent."
-          },
-          screenshotUri: shot.path,
-          ok: true,
-          latencyMs,
-          detail: action.reason ?? null
+        const typeBody = { kind: "input", text: action.text };
+        const command = formatActionShellLine(typeBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, typeBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "type",
+              text: action.text,
+              reason: action.reason ?? "Replayed saved script type",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? null,
+            command
+          });
         });
       } else if (action.type === "assert") {
         const timeoutMs = action.timeoutMs ?? 5000;
         const assertion = action.assertion;
-        const deadline = clock.now() + timeoutMs;
-        for (;; ) {
+        const command = formatAssertShellLine({
+          assertion,
+          text: action.text,
+          timeoutSeconds: timeoutMs / 1000
+        });
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          const deadline = clock.now() + timeoutMs;
+          for (;; ) {
+            if (deps.isAborted()) {
+              return;
+            }
+            const screen = await readScreen2(deps.session);
+            const found = screenHasText(screen.elements, action.text);
+            if (assertion === "visible" && found)
+              break;
+            if (assertion === "not-visible" && !found)
+              break;
+            if (clock.now() >= deadline) {
+              throw new Error(assertion === "visible" ? `Expected visible text not found within ${Math.round(timeoutMs / 1000)}s: ${action.text}` : `Unexpected text still visible after ${Math.round(timeoutMs / 1000)}s: ${action.text}`);
+            }
+            await clock.sleep(400);
+          }
           if (deps.isAborted()) {
-            return "cancelled";
+            return;
           }
-          const screen = await readScreen(deps.session);
-          const found = screenHasText(screen.elements, action.text);
-          if (assertion === "visible" && found)
-            break;
-          if (assertion === "not-visible" && !found)
-            break;
-          if (clock.now() >= deadline) {
-            throw new Error(assertion === "visible" ? `Expected visible text not found within ${Math.round(timeoutMs / 1000)}s: ${action.text}` : `Unexpected text still visible after ${Math.round(timeoutMs / 1000)}s: ${action.text}`);
-          }
-          await clock.sleep(400);
-        }
-        await deps.appendStep({
-          idx: stepIdx,
-          action: {
-            type: "assert",
-            assertion,
-            text: action.text,
-            timeoutMs,
-            reason: action.reason ?? `Assert ${assertion}: ${action.text}`,
-            thoughts: "Replaying the saved script without calling the AI agent."
-          },
-          screenshotUri: shot.path,
-          ok: true,
-          latencyMs,
-          detail: action.reason ?? `${assertion}: ${action.text}`
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "assert",
+              assertion,
+              text: action.text,
+              timeoutMs,
+              reason: action.reason ?? `Assert ${assertion}: ${action.text}`,
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? `${assertion}: ${action.text}`,
+            command
+          });
         });
+        if (deps.isAborted()) {
+          return "cancelled";
+        }
       } else if (action.type === "alert") {
-        await perform(deps.session, {
+        const alertBody = {
           kind: "alert",
           alertAction: action.alertAction === "dismiss" ? "dismiss" : "accept"
-        });
-        await clock.sleep(settleMs);
-        await deps.appendStep({
-          idx: stepIdx,
-          action: {
-            type: "alert",
-            alertAction: action.alertAction === "dismiss" ? "dismiss" : "accept",
-            reason: action.reason ?? "Replayed saved script alert",
-            thoughts: "Replaying the saved script without calling the AI agent."
-          },
-          screenshotUri: shot.path,
-          ok: true,
-          latencyMs,
-          detail: action.reason ?? action.alertAction ?? "accept"
+        };
+        const command = formatActionShellLine(alertBody);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await perform(deps.session, alertBody);
+          await clock.sleep(settleMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "alert",
+              alertAction: action.alertAction === "dismiss" ? "dismiss" : "accept",
+              reason: action.reason ?? "Replayed saved script alert",
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? action.alertAction ?? "accept",
+            command
+          });
         });
       } else {
         const waitMs = Math.min(3000, Math.max(500, action.ms));
-        await clock.sleep(waitMs);
-        await deps.appendStep({
-          idx: stepIdx,
-          action: {
-            type: "wait",
-            ms: waitMs,
-            reason: action.reason ?? `wait ${waitMs}ms`,
-            thoughts: "Replaying the saved script without calling the AI agent."
-          },
-          screenshotUri: shot.path,
-          ok: true,
-          latencyMs,
-          detail: action.reason ?? `wait ${waitMs}ms`
+        const command = formatSleepShellLine(waitMs / 1000);
+        await withCurrentCommand(setCurrentCommand, command, async () => {
+          await clock.sleep(waitMs);
+          await deps.appendStep({
+            idx: stepIdx,
+            action: {
+              type: "wait",
+              ms: waitMs,
+              reason: action.reason ?? `wait ${waitMs}ms`,
+              thoughts: "Replaying the saved script without calling the AI agent."
+            },
+            screenshotUri: shot.path,
+            ok: true,
+            latencyMs,
+            detail: action.reason ?? `wait ${waitMs}ms`,
+            command
+          });
         });
       }
       stepIdx += 1;
@@ -98380,7 +99176,8 @@ async function executeScriptCase(deps) {
       screenshotUri: lastScreenshotUri,
       ok: true,
       latencyMs: 0,
-      detail: "Saved script completed"
+      detail: "Saved script completed",
+      command: null
     });
     return "passed";
   } catch (error40) {
@@ -98398,7 +99195,8 @@ async function executeScriptCase(deps) {
       screenshotUri: lastScreenshotUri,
       ok: false,
       latencyMs: 0,
-      detail: message
+      detail: message,
+      command: null
     });
     return "errored";
   }
@@ -98406,165 +99204,214 @@ async function executeScriptCase(deps) {
 async function executeAgentCase(deps) {
   const decide = deps.decide ?? decideNextAction;
   const perform = deps.performAction ?? performAction;
+  const readScreen2 = deps.readScreen ?? (async (session) => {
+    const screen = await getScreen(session, { full: false });
+    return { elements: screen.elements };
+  });
   const clock = deps.clock ?? defaultClock;
   const settleMs = deps.settleMs ?? POST_ACTION_SETTLE_MS;
   const maxSteps = deps.maxStepsPerCase ?? MAX_STEPS_PER_CASE;
+  const setCurrentCommand = deps.setCurrentCommand ?? noopSetCurrentCommand;
   let stepIdx = 0;
   let caseStatus = "passed";
   let caseError = null;
   let lastScreenshotUri = null;
   const recordedDecisions = [];
+  const decideOnce = async (input) => {
+    const payload = {
+      auth: deps.auth,
+      appContext: deps.appContext,
+      caseTitle: deps.catalogCase.name,
+      instructions: input.flow.instructions,
+      expectedResult: input.flow.expectedResult,
+      stepIndex: stepIdx,
+      imageBase64: input.imageBase64,
+      recentActions: input.recentActions,
+      screenSnapshot: input.screenSnapshot,
+      lastError: input.lastError,
+      defaultAppId: deps.defaultAppId,
+      completedInstructions: [...input.completedInstructions],
+      instructionOrdinal: input.instructionOrdinal,
+      instructionCount: input.instructionCount
+    };
+    let decision = await decide(payload);
+    if (isAbsurdNoScreenshotFail(decision)) {
+      decision = await decide(payload);
+      if (isAbsurdNoScreenshotFail(decision)) {
+        decision = {
+          type: "fail",
+          reason: "Model ignored the attached screenshot (claimed none was provided). Try a stronger vision model in Settings \u2192 Provider.",
+          thoughts: "The vision model returned fail claiming no screenshot was available even though an image was attached to the request. After one retry it still denied the screenshot, so the step was marked failed."
+        };
+      }
+    }
+    decision = coerceScrollIntentToSwipe(decision);
+    decision = continueScrollingInsteadOfComplete({
+      decision,
+      instructions: input.flow.instructions,
+      expectedResult: input.flow.expectedResult,
+      recentActions: input.recentActions,
+      lastSwipeMovedScreen: input.lastSwipeMovedScreen
+    });
+    if ((decision.type === "activate-app" || decision.type === "terminate-app" || decision.type === "restart-app") && !decision.appId && deps.defaultAppId) {
+      decision = { ...decision, appId: deps.defaultAppId };
+    }
+    return decision;
+  };
+  const applyDecision = async (decision) => {
+    if (decision.type === "wait") {
+      const waitMs = Math.min(3000, Math.max(500, decision.ms ?? 1500));
+      await clock.sleep(waitMs);
+      return "continue";
+    }
+    if (decision.type === "verify" || decision.type === "done") {
+      return "done";
+    }
+    if (decision.type === "fail") {
+      return "fail";
+    }
+    if (decision.type === "assert") {
+      const assertion = decision.assertion === "not-visible" ? "not-visible" : "visible";
+      const timeoutMs = Math.min(60000, Math.max(1000, decision.timeoutMs ?? 5000));
+      await runTextAssert({
+        session: deps.session,
+        readScreen: readScreen2,
+        clock,
+        isAborted: deps.isAborted,
+        assertion,
+        text: decision.text ?? "",
+        timeoutMs
+      });
+      return "continue";
+    }
+    const body = decisionToActionRequest(decision, { defaultAppId: deps.defaultAppId });
+    if (!body) {
+      throw new Error(`${decision.type} is missing required fields`);
+    }
+    try {
+      await perform(deps.session, body);
+    } catch (error40) {
+      if (error40 instanceof ActionNotFoundError && (body.id || body.label) && decision.x != null && decision.y != null) {
+        await perform(deps.session, {
+          kind: body.kind === "input" ? "input" : "tap",
+          x: decision.x,
+          y: decision.y,
+          text: body.text,
+          double: body.double,
+          durationMs: body.durationMs
+        });
+      } else {
+        throw error40;
+      }
+    }
+    await clock.sleep(settleMs);
+    return "continue";
+  };
   try {
-    const flows2 = deps.catalogCase.flows.length > 0 ? deps.catalogCase.flows : [{ id: "empty", instructions: "", expectedResult: "", flowId: null }];
-    for (const flow of flows2) {
+    const instructionQueue = flattenCaseInstructions(deps.catalogCase.flows.length > 0 ? deps.catalogCase.flows : [{ id: "empty", instructions: "", expectedResult: "", flowId: null }]);
+    const recentActions = [];
+    const completedInstructions = [];
+    let prevFingerprint = null;
+    for (let instructionIndex = 0;instructionIndex < instructionQueue.length; instructionIndex++) {
+      const instruction = instructionQueue[instructionIndex];
+      if (!instruction)
+        break;
       if (deps.isAborted()) {
         caseStatus = "cancelled";
         break;
       }
-      const recentActions = [];
-      let flowDone = false;
-      for (let attempt = 0;attempt < maxSteps && !flowDone; attempt++) {
+      let instructionDone = false;
+      for (let attempt = 0;attempt < maxSteps && !instructionDone; attempt++) {
         if (deps.isAborted()) {
           caseStatus = "cancelled";
-          flowDone = true;
+          instructionDone = true;
           break;
         }
         const shotStarted = clock.now();
         const shot = await deps.session.screenshot();
         lastScreenshotUri = shot.path;
+        const tree = await readCleanedTree(readScreen2, deps.session);
+        const fingerprint = screenshotFingerprint(shot.base64);
+        const lastAction = recentActions.at(-1);
+        const lastSwipeMovedScreen = lastAction?.type === "swipe" && prevFingerprint != null && fingerprint !== prevFingerprint;
         if (deps.isAborted()) {
           caseStatus = "cancelled";
-          flowDone = true;
+          instructionDone = true;
           break;
         }
-        let decision = await decide({
-          auth: deps.auth,
-          appContext: deps.appContext,
-          caseTitle: deps.catalogCase.name,
-          instructions: flow.instructions,
-          expectedResult: flow.expectedResult,
-          stepIndex: stepIdx,
+        const decideInput = {
+          flow: instruction,
           imageBase64: shot.base64,
-          recentActions
-        });
-        if (isAbsurdNoScreenshotFail(decision)) {
-          decision = await decide({
-            auth: deps.auth,
-            appContext: deps.appContext,
-            caseTitle: deps.catalogCase.name,
-            instructions: flow.instructions,
-            expectedResult: flow.expectedResult,
-            stepIndex: stepIdx,
-            imageBase64: shot.base64,
-            recentActions
-          });
-          if (isAbsurdNoScreenshotFail(decision)) {
-            decision = {
-              type: "fail",
-              reason: "Model ignored the attached screenshot (claimed none was provided). Try a stronger vision model in Settings \u2192 Provider.",
-              thoughts: "The vision model returned fail claiming no screenshot was available even though an image was attached to the request. After one retry it still denied the screenshot, so the step was marked failed."
-            };
-          }
-        }
+          recentActions,
+          screenSnapshot: tree.snapshot,
+          lastSwipeMovedScreen,
+          completedInstructions,
+          instructionOrdinal: instructionIndex + 1,
+          instructionCount: instructionQueue.length
+        };
+        let decision = await decideOnce(decideInput);
+        prevFingerprint = fingerprint;
         const latencyMs = clock.now() - shotStarted;
         if (deps.isAborted()) {
           caseStatus = "cancelled";
-          flowDone = true;
+          instructionDone = true;
           break;
         }
-        recentActions.push(decision);
-        recordedDecisions.push(decision);
-        if (decision.type === "tap") {
-          const tapBody = { kind: "tap" };
-          if (prefersScreenshotTap(decision)) {
-            tapBody.x = decision.x;
-            tapBody.y = decision.y;
-          } else if (decision.label) {
-            tapBody.label = decision.label;
-            if (decision.id)
-              tapBody.id = decision.id;
-          } else if (decision.id) {
-            tapBody.id = decision.id;
-          } else {
-            tapBody.x = decision.x ?? 500;
-            tapBody.y = decision.y ?? 500;
+        const applyWithRetry = async () => {
+          try {
+            return await applyDecision(decision);
+          } catch (error40) {
+            if (!isRetriableActionError(error40) || deps.isAborted())
+              throw error40;
+            const failed = decision;
+            decision = await decideOnce({
+              ...decideInput,
+              recentActions: [...recentActions, failed],
+              lastError: error40 instanceof Error ? error40.message : String(error40)
+            });
+            const retryCommand = commandForDecision(decision, deps.defaultAppId);
+            await setCurrentCommand(retryCommand);
+            return await applyDecision(decision);
           }
-          await perform(deps.session, tapBody);
-          await clock.sleep(settleMs);
-          await deps.appendStep({
-            idx: stepIdx,
-            action: decision,
-            screenshotUri: shot.path,
-            ok: true,
-            latencyMs,
-            detail: decision.reason ?? null
-          });
-        } else if (decision.type === "alert") {
-          await perform(deps.session, {
-            kind: "alert",
-            alertAction: decision.alertAction === "dismiss" ? "dismiss" : "accept"
-          });
-          await clock.sleep(settleMs);
-          await deps.appendStep({
-            idx: stepIdx,
-            action: decision,
-            screenshotUri: shot.path,
-            ok: true,
-            latencyMs,
-            detail: decision.reason ?? null
-          });
-        } else if (decision.type === "type") {
-          await perform(deps.session, { kind: "input", text: decision.text ?? "" });
-          await clock.sleep(settleMs);
-          await deps.appendStep({
-            idx: stepIdx,
-            action: decision,
-            screenshotUri: shot.path,
-            ok: true,
-            latencyMs,
-            detail: decision.reason ?? null
-          });
-        } else if (decision.type === "wait") {
-          const waitMs = Math.min(3000, Math.max(500, decision.ms ?? 1500));
-          await clock.sleep(waitMs);
-          await deps.appendStep({
-            idx: stepIdx,
-            action: decision,
-            screenshotUri: shot.path,
-            ok: true,
-            latencyMs,
-            detail: decision.reason ?? `wait ${waitMs}ms`
-          });
-        } else if (decision.type === "verify" || decision.type === "done") {
-          await deps.appendStep({
-            idx: stepIdx,
-            action: decision,
-            screenshotUri: shot.path,
-            ok: true,
-            latencyMs,
-            detail: decision.reason ?? null
-          });
-          flowDone = true;
-        } else {
+        };
+        const recordStep = async (command, outcome2) => {
+          recentActions.push(decision);
+          recordedDecisions.push(decision);
           await deps.appendStep({
             idx: stepIdx,
             action: decision,
             screenshotUri: shot.path,
-            ok: false,
+            ok: outcome2 !== "fail",
             latencyMs,
-            detail: decision.reason ?? "Agent failed the step"
+            detail: decision.type === "wait" ? decision.reason ?? `wait ${Math.min(3000, Math.max(500, decision.ms ?? 1500))}ms` : decision.reason ?? (outcome2 === "fail" ? "Agent failed the step" : null),
+            command
           });
+        };
+        const initialCommand = commandForDecision(decision, deps.defaultAppId);
+        const outcome = initialCommand ? await withCurrentCommand(setCurrentCommand, initialCommand, async () => {
+          const result = await applyWithRetry();
+          await recordStep(commandForDecision(decision, deps.defaultAppId), result);
+          return result;
+        }) : await (async () => {
+          const result = await applyWithRetry();
+          await recordStep(null, result);
+          return result;
+        })();
+        if (outcome === "done") {
+          instructionDone = true;
+          completedInstructions.push(instruction.instructions);
+        } else if (outcome === "fail") {
           caseStatus = "errored";
-          caseError = decision.reason ?? "Agent marked the flow as failed";
-          flowDone = true;
+          caseError = decision.reason ?? "Agent marked the instruction as failed";
+          instructionDone = true;
         }
         stepIdx += 1;
       }
       if (caseStatus === "errored" || caseStatus === "cancelled")
         break;
-      if (!flowDone) {
+      if (!instructionDone) {
         caseStatus = "errored";
-        caseError = `Exceeded max steps (${maxSteps}) for a flow`;
+        caseError = `Exceeded max steps (${maxSteps}) for instruction ${instructionIndex + 1} of ${instructionQueue.length}`;
         break;
       }
     }
@@ -98584,7 +99431,8 @@ async function executeAgentCase(deps) {
         screenshotUri: lastScreenshotUri,
         ok: false,
         latencyMs: 0,
-        detail: caseError
+        detail: caseError,
+        command: null
       });
     }
   }
@@ -98668,6 +99516,7 @@ async function loadRun(runId) {
       ok: step.ok === 1,
       latencyMs: step.latencyMs,
       detail: step.detail,
+      command: step.command ?? null,
       createdAt: step.createdAt
     }));
     const caseMode = test.executionMode === "script" || test.executionMode === "agent" ? test.executionMode : null;
@@ -98680,6 +99529,7 @@ async function loadRun(runId) {
       error: test.error,
       startedAt: test.startedAt,
       finishedAt: test.finishedAt,
+      currentCommand: test.currentCommand ?? null,
       steps
     });
   }
@@ -98709,9 +99559,14 @@ async function appendStep(input) {
     ok: input.ok ? 1 : 0,
     latencyMs: Math.max(0, Math.round(input.latencyMs)),
     detail: input.detail,
+    command: input.command,
     createdAt: Date.now()
   });
 }
+async function setCurrentCommand(runTestId, command) {
+  const db = getCatalogDb();
+  await db.update(runTests).set({ currentCommand: command }).where(eq(runTests.id, runTestId));
+}
 async function updateCaseLastRun(caseId, status, at) {
   const db = getCatalogDb();
   await db.update(cases).set({
@@ -98734,7 +99589,8 @@ async function persistCancelled(runId) {
       await db.update(runTests).set({
         status: "cancelled",
         error: "Cancelled by user",
-        finishedAt
+        finishedAt,
+        currentCommand: null
       }).where(eq(runTests.id, test.id));
     }
   }
@@ -98754,6 +99610,9 @@ async function executeScriptCase2(input) {
         ...step
       });
     },
+    setCurrentCommand: async (command) => {
+      await setCurrentCommand(input.runTestId, command);
+    },
     clock: { sleep, now: () => Date.now() }
   });
 }
@@ -98774,8 +99633,12 @@ async function executeAgentCase2(input) {
         ...step
       });
     },
+    setCurrentCommand: async (command) => {
+      await setCurrentCommand(input.runTestId, command);
+    },
     decide: decideNextAction,
-    clock: { sleep, now: () => Date.now() }
+    clock: { sleep, now: () => Date.now() },
+    defaultAppId: input.defaultAppId
   });
 }
 async function executeCase(input) {
@@ -98788,7 +99651,8 @@ async function executeCase(input) {
     status: "running",
     startedAt,
     error: null,
-    executionMode: input.caseMode
+    executionMode: input.caseMode,
+    currentCommand: null
   }).where(eq(runTests.id, input.runTestId));
   let caseStatus;
   let caseError = null;
@@ -98815,7 +99679,8 @@ async function executeCase(input) {
       caseId: input.caseId,
       appContext: input.appContext,
       session: input.session,
-      auth: input.auth
+      auth: input.auth,
+      defaultAppId: input.defaultAppId
     });
     caseStatus = result.status;
     decisions = result.decisions;
@@ -98828,7 +99693,8 @@ async function executeCase(input) {
   await db.update(runTests).set({
     status: caseStatus,
     error: caseError,
-    finishedAt
+    finishedAt,
+    currentCommand: null
   }).where(eq(runTests.id, input.runTestId));
   await updateCaseLastRun(input.caseId, caseStatus, finishedAt);
   if (caseStatus === "passed" && input.caseMode === "agent") {
@@ -98926,7 +99792,8 @@ async function executeRun(runId) {
         appContext: app.context,
         session,
         auth,
-        caseMode
+        caseMode,
+        defaultAppId: run.platform === "ios" ? app.iosBundleId || undefined : app.androidApplicationId || undefined
       });
       if (status === "cancelled" || isAborted2(runId)) {
         await persistCancelled(runId);
@@ -99406,7 +100273,9 @@ function createSessionRoutes() {
     try {
       const { session } = requireActiveSession();
       const full = c.req.query("full") === "1" || c.req.query("full") === "true";
-      const result = await getScreen(session, { full });
+      const pauseQuery = c.req.query("pauseMjpeg");
+      const pauseMjpeg = pauseQuery !== "0" && pauseQuery !== "false";
+      const result = await getScreen(session, { full, pauseMjpeg });
       return c.json(screenResponseSchema.parse(result));
     } catch (error40) {
       const gone = sessionErrorResponse(error40);