@@ -98,3 +98,12 @@ test('without a usable root the device screen is the viewport, and a bad screen
     ),
   ).toEqual({ kind: 'derived', rect: { x: 0, y: 0, width: 320, height: 240 } });
 });
+
+test('a screen box with one dimension is invalid, and a null role description is omitted', () => {
+  expect(resolveIosAxTreeViewport([{ type: 'Application' }], { width: 440 })).toEqual({
+    kind: 'missing',
+    reason: 'invalid',
+  });
+  const [node] = flattenIosTree({ type: 'Button', role_description: null });
+  expect(node?.roleDescription).toBeUndefined();
+});
@@ -25,7 +25,7 @@ export type IosTreeNode = {
   role?: string;
   subrole?: string | null;
   selected?: boolean;
-  role_description?: string;
+  role_description?: IosTextAttribute;
   hittable?: boolean;
   traits?: string[];
   pid?: number;
@@ -65,7 +65,7 @@ function mapIosNode(
     selected: readIosNodeSelected(node),
     password: node.subrole === 'AXSecureTextField' ? true : undefined,
     heading: node.traits?.includes('Header') === true ? true : undefined,
-    roleDescription: node.role_description,
+    roleDescription: scalarText(node.role_description),
     hittable: node.hittable,
     depth: options.depth,
     parentIndex: options.parentIndex,
@@ -155,7 +155,7 @@ export function resolveIosAxTreeViewport(
     (Array.isArray(tree) ? tree : [tree]).map(viewportRoot),
   );
   if (evidence?.kind === 'reported') return { kind: 'derived', rect: evidence.rect };
-  if (screen?.width !== undefined && screen.height !== undefined) {
+  if (screen !== undefined && (screen.width !== undefined || screen.height !== undefined)) {
     return isFiniteNumber(screen.width) &&
       isFiniteNumber(screen.height) &&
       screen.width > 0 &&
 
@@ -520,6 +520,24 @@ test('an iOS screenshot is rescaled from its native scale to the requested densi
   assert.deepEqual(await readPngSize(path.join(directory, 'native.png')), { width: 6, height: 6 });
 });
 
+test('an iOS screenshot of an interface rotated since health keeps its aspect at the right scale', async () => {
+  // health read a 2x4-point portrait screen; the app has since rotated, so the 3x capture is 12x6.
+  const { interactor } = await liveInteractor('ios', {
+    screen: { width: 2, height: 4 },
+    respond: {
+      'GET /api/v1/execution/device-proxy/run-1/screenshot': () => ({
+        contentType: 'image/png',
+        body: [...PNG.sync.write(new PNG({ width: 12, height: 6 }))],
+      }),
+    },
+  });
+  const outPath = path.join(await mkdtempForTest('agent-device-revyl-shot-rotated-'), 'shot.png');
+
+  await interactor.screenshot(outPath);
+
+  assert.deepEqual(await readPngSize(outPath), { width: 4, height: 2 });
+});
+
 test('two captures of one path each keep their own temporary file', async () => {
   // Both writes land in the same directory with the same base name. If they shared a temporary sibling, the
   // first rename would move it away and the second would fail with ENOENT on a file that is no longer there.
 
@@ -369,7 +369,7 @@ export function createRevylInteractor(session: RevylSession, signal?: AbortSigna
 /** Rescales an iOS capture from the density its point size implies to the one the caller asked for. */
 async function normalizeRevylIosDensity(
   file: string,
-  screen: { width: number } | undefined,
+  screen: { width: number; height: number } | undefined,
   pixelDensity: number | undefined,
 ): Promise<void> {
   // The host reports the requested density for every iOS simulator capture, so an image whose source
@@ -388,7 +388,9 @@ async function normalizeRevylIosDensity(
       import('@agent-device/capture-kit/screenshot-density'),
     ]);
   const size = await readPngSize(file);
-  const target = computeDensityScaledScreenshotSize(size, size.width / screen.width, pixelDensity);
+  // The longer sides match whichever way the app has rotated its interface since `health` was read.
+  const sourceDensity = Math.max(size.width, size.height) / Math.max(screen.width, screen.height);
+  const target = computeDensityScaledScreenshotSize(size, sourceDensity, pixelDensity);
   if (target) await resizePngFile(file, target.width, target.height);
 }
 
 
@@ -97,11 +97,6 @@ export async function startRevylFixtureBackend(
   let health503Polls = 0;
   /** The platform and session id of the last `start_device`, which is what later answers report. */
   let started: { platform: string; sessionId: string } | undefined;
-  /** The session a stop or a run cancel ends: the id in a session stop, the started run's for a cancel. */
-  const stoppedSessionIn = (url: string): string | undefined =>
-    url.startsWith('/api/v1/execution/device/status/cancel/')
-      ? started?.sessionId
-      : sessionIdIn(url);
   /**
    * The sessions Revyl would hold right now, by id. A session is made when its `start_device` is
    * *answered* — with a start delay, later than the request — and a confirmed `/stop` for that id ends
@@ -140,7 +135,7 @@ export async function startRevylFixtureBackend(
         answered.push(`${method} ${url}`);
         if (response.statusCode !== 200 || !lifecycleAccepted(sent?.body)) return;
         if (url.endsWith('/start_device') && started) openSessions.add(started.sessionId);
-        const stoppedId = stoppedSessionIn(url);
+        const stoppedId = sessionIdIn(url);
         if (stoppedId !== undefined) openSessions.delete(stoppedId);
       });
       const override = overrides.get(`${method} ${url}`);
@@ -181,7 +176,7 @@ export async function startRevylFixtureBackend(
         stop: () => {
           // With `sessionExistsOnceStarted`, a stop that arrives before the start has answered names a
           // session Revyl never made. The caller must not read that 404 as a release it never got.
-          const stopping = stoppedSessionIn(url);
+          const stopping = sessionIdIn(url);
           if (options.sessionExistsOnceStarted && (!stopping || !openSessions.has(stopping))) {
             return { status: 404, body: { detail: 'no such session', error: 'Not Found' } };
           }
@@ -306,11 +301,10 @@ function fixtureRoute(url: string): string {
     return 'action';
   }
   if (isDeviceSessionRoute(url) && url.endsWith('/stop')) return 'stop';
-  if (url.startsWith('/api/v1/execution/device/status/cancel/')) return 'stop';
   return 'unknown';
 }
 
-/** A `/stop` or run cancel ends its session exactly when the client accepts the answer. */
+/** A `/stop` ends its session exactly when the client accepts the answer. */
 function lifecycleAccepted(body: unknown): boolean {
   if (body === null || typeof body !== 'object') return false;
   const verdict = body as { success?: unknown; request_accepted?: unknown };
 
@@ -106,12 +106,6 @@ test('reads the typed failure one status names, on the route that answered', asy
       code: 'SESSION_NOT_FOUND',
       call: async (client) => await client.stopDeviceSession('session-1'),
     },
-    {
-      status: 410,
-      reason: 'provider-session-gone',
-      code: 'SESSION_NOT_FOUND',
-      call: async (client) => await client.cancelDeviceRun('run-1'),
-    },
     {
       // The same status on a route that names no session is a request the backend did not route.
       status: 404,
@@ -236,15 +230,6 @@ test('a lifecycle stop that Revyl answers with a refusal is still a refusal', as
     async () => await unaccepted.stopDeviceSession('session-1'),
     (error: unknown) => error instanceof AppError && error.details?.reason === 'provider-refused',
   );
-
-  const canceled = clientResponding(() => jsonResponse({ success: false }));
-  await assert.rejects(
-    async () => await canceled.cancelDeviceRun('run-1'),
-    (error: unknown) =>
-      error instanceof AppError &&
-      error.details?.reason === 'provider-refused' &&
-      error.details?.operation === 'cancel',
-  );
 });
 
 test('a confirmed lifecycle stop reports the session Revyl ended', async () => {
 
@@ -9,8 +9,6 @@ import type {
   RevylWorkerActionResponse,
   RevylWorkerConnection,
   RevylWorkerHealth,
-  RevylWorkflowCancelResponse,
-  RevylWorkflowLifecycleResponse,
 } from './revyl-types.ts';
 
 export const REVYL_DEFAULT_BACKEND_URL = 'https://backend.revyl.ai';
@@ -50,7 +48,7 @@ type RevylRequest = Readonly<{
   timeoutMs?: number;
   /**
    * Defaults to true for GET and false for POST. A POST opts in only when Revyl documents it as
-   * idempotent, which `/stop` and `/status/cancel` are; a device action is never replayed.
+   * idempotent, which `/stop` is; a device action is never replayed.
    */
   retry?: boolean;
   /** A device-proxy action carries the agent header; an execution-API call does not. */
@@ -84,8 +82,6 @@ export type RevylClient = Readonly<{
     signal?: AbortSignal,
   ): Promise<RevylWorkerActionResponse>;
   stopDeviceSession(sessionId: string): Promise<RevylDeviceSessionStopResponse>;
-  /** The fallback for a session whose start never returned an id: cancel the run itself. */
-  cancelDeviceRun(workflowRunId: string): Promise<void>;
   /** Cheap enough to run on every `connect`: it authenticates without starting a device. */
   verifyCredentials(signal?: AbortSignal): Promise<void>;
 }>;
@@ -204,15 +200,6 @@ export function createRevylClient(options: RevylClientOptions): RevylClient {
       assertLifecycleAccepted('stop', response);
       return response;
     },
-    async cancelDeviceRun(workflowRunId) {
-      const response = await json<RevylWorkflowCancelResponse>({
-        method: 'POST',
-        path: `/api/v1/execution/device/status/cancel/${encodeURIComponent(workflowRunId)}`,
-        retry: true,
-        route: 'session',
-      });
-      assertLifecycleAccepted('cancel', response);
-    },
     async verifyCredentials(signal) {
       await json<unknown>({
         method: 'GET',
@@ -319,21 +306,19 @@ function assertSuccess(request: RevylRequest, response: RevylResponse): void {
 }
 
 /**
- * Revyl's `/stop` and `/status/cancel` answers name the verdict they reached, and a 200 that says
- * `success: false` or `request_accepted: false` is a refusal the caller still has to act on: the
- * session is rented either way.
+ * Revyl's `/stop` answer names the verdict it reached, and a 200 that says `success: false` or
+ * `request_accepted: false` is a refusal the caller still has to act on: the session is rented
+ * either way.
  */
 function assertLifecycleAccepted(
-  operation: 'stop' | 'cancel',
-  response: RevylWorkflowLifecycleResponse,
+  operation: 'stop',
+  response: RevylDeviceSessionStopResponse,
 ): void {
   if (response.success === true && (response.request_accepted ?? true) === true) return;
   const message = typeof response.message === 'string' ? response.message : undefined;
   throw new AppError(
     'COMMAND_FAILED',
-    `Revyl did not ${operation === 'stop' ? 'stop the session' : 'cancel the run'}${
-      message === undefined ? '' : `: ${message}`
-    }`,
+    `Revyl did not stop the session${message === undefined ? '' : `: ${message}`}`,
     {
       reason: 'provider-refused',
       operation,
 
@@ -479,19 +479,11 @@ async function sleepBefore(deadline: RevylDeadline, signal?: AbortSignal): Promi
 }
 
 /**
- * Ends one Revyl session. `/stop` is idempotent, so a repeat release is safe, and a session with no
- * run to route to is ended by its session id — the same pair of ends Revyl's own clients take.
+ * Ends one Revyl session by the id this runtime issued for it. `/stop` is idempotent, so a repeat
+ * release is safe; every rented session carries that id, so no run-level cancel is needed.
  */
-export async function stopRevylSession(
-  client: RevylClient,
-  runId: string | undefined,
-  sessionId: string | undefined,
-): Promise<void> {
-  if (sessionId) {
-    await client.stopDeviceSession(sessionId);
-    return;
-  }
-  if (runId) await client.cancelDeviceRun(runId);
+export async function stopRevylSession(client: RevylClient, sessionId: string): Promise<void> {
+  await client.stopDeviceSession(sessionId);
 }
 
 function readRevylScreenSize(health: RevylWorkerHealth): RevylScreenSize | undefined {
 
@@ -53,17 +53,6 @@ export type RevylDeviceSessionStopResponse = Readonly<{
   message?: string;
 }>;
 
-/** Revyl's answer to cancelling a run: the same verdict spelling, without the acceptance field. */
-export type RevylWorkflowCancelResponse = Readonly<{
-  success?: boolean;
-  message?: string;
-  task_id?: string;
-}>;
-
-/** What either lifecycle answer has to say for the runtime to treat the end as done. */
-export type RevylWorkflowLifecycleResponse = RevylDeviceSessionStopResponse &
-  RevylWorkflowCancelResponse;
-
 /**
  * A device-proxy action result. `install` reports its verdict as `Success`, capitalized, where
  * every other action uses `success`; a refusal arrives in a 200 body rather than a status code.
 
@@ -22,7 +22,7 @@ afterEach(async () => {
 
 /** Stops the fixture recorded, which is what every lifecycle assertion reads. */
 function stops(fixture: RevylFixtureBackend): string[] {
-  return fixture.paths().filter((path) => path.includes('/stop') || path.includes('/cancel/'));
+  return fixture.paths().filter((path) => path.includes('/stop'));
 }
 
 test('a lease start waits for the worker and the device, and reports the rented device', async () => {
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ afterEach(async () => {`
`22`	`22`
`23`	`23`	`/** Stops the fixture recorded, which is what every lifecycle assertion reads. */`
`24`	`24`	`function stops(fixture: RevylFixtureBackend): string[] {`
`25`		`- return fixture.paths().filter((path) => path.includes('/stop') \|\| path.includes('/cancel/'));`
	`25`	`+ return fixture.paths().filter((path) => path.includes('/stop'));`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`test('a lease start waits for the worker and the device, and reports the rented device', async () => {`