@@ -4,7 +4,7 @@ import { alertCliReader, alertDaemonWriter } from './alert.ts';
 import { diffCliReader } from './diff.ts';
 import { snapshotCliOutput } from './output.ts';
 import { screenshotCliReader, screenshotDaemonWriter } from './screenshot.ts';
-import { settingsCliReader, settingsDaemonWriter } from './settings.ts';
+import { settingsCliReader, settingsCommandFacet, settingsDaemonWriter } from './settings.ts';
 import { snapshotCliReader } from './snapshot.ts';
 import { waitCliReader, waitDaemonWriter } from './wait.ts';
 
@@ -187,4 +187,26 @@ describe('capture command interface', () => {
       positionals: ['permission', 'grant', 'camera', 'limited'],
     });
   });
+
+  // #1796: the Android revoke warning rides `warnings`; the human CLI line must show it.
+  test('settings CLI output renders response warnings after the message', () => {
+    const warning = 'Revoking android.permission.CAMERA while it was granted made Android kill …';
+    const output = settingsCommandFacet.cliOutputFormatter!({
+      input: {},
+      result: { setting: 'permission', state: 'reset', message: 'Updated setting: permission' },
+    });
+    expect(output.text).toBe('Updated setting: permission');
+
+    const warned = settingsCommandFacet.cliOutputFormatter!({
+      input: {},
+      result: {
+        setting: 'permission',
+        state: 'reset',
+        message: 'Updated setting: permission',
+        warnings: [warning],
+      },
+    });
+    expect(warned.text).toBe(`Updated setting: permission\nWarning: ${warning}`);
+    expect(warned.data).toMatchObject({ warnings: [warning] });
+  });
 });
@@ -17,6 +17,7 @@ import {
 import type { CliReader, DaemonWriter } from '../cli-grammar/types.ts';
 import { defineCommandFacet } from '../family/types.ts';
 import { defineFieldCommandMetadata } from '../field-command-contract.ts';
+import { messageWithWarningsOutput } from '../output-common.ts';
 
 const SETTINGS_COMMAND_NAME = 'settings';
 const settingsCommandDescription =
@@ -59,13 +60,15 @@ export const settingsCommandFacet = defineCommandFacet({
   text: {
     summary: 'Change OS settings and app permissions',
     cliDetail:
-      'macOS supports only settings appearance <light|dark|toggle> and settings permission <grant|reset> <accessibility|screen-recording|input-monitoring>; wifi|airplane|location|animations remain unsupported on macOS. Mobile permission actions use the active session app.',
+      'macOS supports only settings appearance <light|dark|toggle> and settings permission <grant|reset> <accessibility|screen-recording|input-monitoring>; wifi|airplane|location|animations remain unsupported on macOS. Mobile permission actions use the active session app. On Android, deny|reset of a permission the app currently holds kills the app process; the response warns, and open <app> --relaunch restores it.',
   },
   metadata: settingsCommandMetadata,
   definition: settingsCommandDefinition,
   cliSchema: settingsCliSchema,
   cliReader: settingsCliReader,
   daemonWriter: settingsDaemonWriter,
+  // Android permission revokes append a relaunch warning (#1796); render it for humans too.
+  cliOutputFormatter: messageWithWarningsOutput,
 });
 
 // fallow-ignore-next-line complexity
 
@@ -18,6 +18,23 @@ export function messageCliOutput(result: Record<string, unknown>): CliOutput {
   return { data: result, text: readCommandMessage(result) };
 }
 
+/**
+ * `messageCliOutput` plus one `Warning:` line per entry of the response's `warnings`
+ * array — the composable warnings channel (`open`, `debug`, snapshot capture use it too),
+ * so a warning the daemon appended reaches the human CLI reader, not only `--json`.
+ */
+export const messageWithWarningsOutput = resultOutput(
+  (result: Record<string, unknown>): CliOutput => {
+    const output = messageCliOutput(result);
+    const warnings = Array.isArray(result.warnings)
+      ? result.warnings.filter((warning): warning is string => typeof warning === 'string')
+      : [];
+    if (warnings.length === 0) return output;
+    const lines = [output.text, ...warnings.map((warning) => `Warning: ${warning}`)];
+    return { data: output.data, text: lines.filter(Boolean).join('\n') };
+  },
+);
+
 /**
  * ADR 0014: a reusable ref in a PARTIAL result renders in ready-to-copy
  * `@eN~s<refsGeneration>` form so a human CLI caller can paste it into the next
 
@@ -1,6 +1,10 @@
 import { test } from 'vitest';
 import assert from 'node:assert/strict';
-import { setAndroidSetting } from '../settings.ts';
+import {
+  androidRevokedGrantedPermissionWarning,
+  parseAndroidGrantedRuntimePermissions,
+  setAndroidSetting,
+} from '../settings.ts';
 import {
   ANDROID_EMULATOR,
   assertRejectsAppError,
@@ -177,6 +181,106 @@ test('setAndroidSetting permission reset notifications clears permission flags f
   );
 });
 
+// #1796: Android kills the app when a permission it holds is revoked. The prior grant state is
+// read before `pm revoke`, and a granted -> revoked transition surfaces as a warning + typed field.
+const DUMPSYS_MICROPHONE_GRANTED = [
+  'Packages:',
+  '  Package [com.example.app] (abc):',
+  '    User 0: ceDataInode=0 installed=true',
+  '      runtime permissions:',
+  '        android.permission.RECORD_AUDIO: granted=true, flags=[ USER_SET|USER_SENSITIVE_WHEN_GRANTED]',
+  '        android.permission.CAMERA: granted=false, flags=[ USER_SENSITIVE_WHEN_GRANTED]',
+].join('\n');
+
+test.each(['deny', 'reset'] as const)(
+  'setAndroidSetting permission %s warns that revoking a granted permission killed the app',
+  async (action) => {
+    await withFakeAdb(
+      (args) =>
+        args.join(' ') === 'shell dumpsys package com.example.app'
+          ? DUMPSYS_MICROPHONE_GRANTED
+          : undefined,
+      async ({ calls, device }) => {
+        const result = await setAndroidSetting(device, 'permission', action, 'com.example.app', {
+          permissionTarget: 'microphone',
+        });
+        const flat = calls.map((args) => args.join(' '));
+        // The state is read BEFORE the revoke: after it, dumpsys would already say false.
+        assert.ok(
+          flat.indexOf('shell dumpsys package com.example.app') <
+            flat.indexOf('shell pm revoke com.example.app android.permission.RECORD_AUDIO'),
+          flat.join('; '),
+        );
+        assert.deepEqual(result, {
+          permission: 'android.permission.RECORD_AUDIO',
+          wasGranted: true,
+          warnings: [
+            androidRevokedGrantedPermissionWarning(
+              'com.example.app',
+              'android.permission.RECORD_AUDIO',
+            ),
+          ],
+        });
+        assert.match(String(result?.warnings), /open com\.example\.app --relaunch/);
+      },
+    );
+  },
+);
+
+test('setAndroidSetting permission deny stays quiet when the permission was not granted', async () => {
+  await withFakeAdb(
+    (args) =>
+      args.join(' ') === 'shell dumpsys package com.example.app'
+        ? DUMPSYS_MICROPHONE_GRANTED
+        : undefined,
+    async ({ device }) => {
+      const result = await setAndroidSetting(device, 'permission', 'deny', 'com.example.app', {
+        permissionTarget: 'camera',
+      });
+      assert.deepEqual(result, { permission: 'android.permission.CAMERA', wasGranted: false });
+    },
+  );
+});
+
+test('setAndroidSetting permission grant does not read grant state', async () => {
+  await withFakeAdb(
+    () => undefined,
+    async ({ calls, device }) => {
+      const result = await setAndroidSetting(device, 'permission', 'grant', 'com.example.app', {
+        permissionTarget: 'camera',
+      });
+      assert.equal(result, undefined);
+      assert.deepEqual(calls, [
+        ['shell', 'pm', 'grant', 'com.example.app', 'android.permission.CAMERA'],
+      ]);
+    },
+  );
+});
+
+test('setAndroidSetting permission reset notifications warns when POST_NOTIFICATIONS was granted', async () => {
+  await withFakeAdb(
+    (args) =>
+      args.join(' ') === 'shell dumpsys package com.example.app'
+        ? '      runtime permissions:\n        android.permission.POST_NOTIFICATIONS: granted=true, flags=[ USER_SET]'
+        : undefined,
+    async ({ device }) => {
+      const result = await setAndroidSetting(device, 'permission', 'reset', 'com.example.app', {
+        permissionTarget: 'notifications',
+      });
+      assert.equal(result?.wasGranted, true);
+      assert.equal(Array.isArray(result?.warnings), true);
+    },
+  );
+});
+
+test('parseAndroidGrantedRuntimePermissions reads only granted=true runtime permissions', () => {
+  assert.deepEqual(
+    [...parseAndroidGrantedRuntimePermissions(DUMPSYS_MICROPHONE_GRANTED)],
+    ['android.permission.RECORD_AUDIO'],
+  );
+  assert.deepEqual([...parseAndroidGrantedRuntimePermissions('')], []);
+});
+
 test('setAndroidSetting permission reset camera clears permission flags for reprompt', async () => {
   await withFakeAdb(
     () => undefined,
 
@@ -142,34 +142,115 @@ export async function setAndroidSetting(
       if (!appPackage) {
         throw new AppError('INVALID_ARGS', 'permission setting requires an active app in session');
       }
-      const action = parsePermissionAction(state);
-      const target = parseAndroidPermissionTarget(
-        options?.permissionTarget,
-        options?.permissionMode,
-      );
-      if (target.kind === 'notifications') {
-        await setAndroidNotificationPermission(device, appPackage, action, target);
-        return;
-      }
-      const pmAction = action === 'grant' ? 'grant' : 'revoke';
-      if (target.type === 'photos') {
-        const permission = await setAndroidPhotoPermission(device, appPackage, pmAction);
-        if (action === 'reset') {
-          await clearAndroidPermissionFlags(device, appPackage, permission);
-        }
-        return;
-      }
-      await runAndroidAdb(device, ['shell', 'pm', pmAction, appPackage, target.value]);
-      if (action === 'reset') {
-        await clearAndroidPermissionFlags(device, appPackage, target.value);
-      }
-      return;
+      return await setAndroidPermission(device, appPackage, state, options);
     }
     default:
       throw new AppError('INVALID_ARGS', `Unsupported setting: ${setting}`);
   }
 }
 
+/**
+ * Android kills the app's process whenever a runtime permission it currently holds is
+ * revoked (`pm revoke` after a grant, foreground or background), so a `deny`/`reset` that
+ * follows a grant leaves the session pointing at a dead app and the next selector fails
+ * against the launcher (#1796). Revoking a permission the app does not hold is harmless.
+ * The prior grant state is read before the revoke so the response can say so.
+ */
+export function androidRevokedGrantedPermissionWarning(
+  appPackage: string,
+  permission: string,
+): string {
+  return (
+    `Revoking ${permission} while it was granted made Android kill ${appPackage}; the app is ` +
+    `no longer running. Relaunch it with open ${appPackage} --relaunch before the next interaction.`
+  );
+}
+
+type AndroidPermissionTarget = ReturnType<typeof parseAndroidPermissionTarget>;
+
+async function setAndroidPermission(
+  device: DeviceInfo,
+  appPackage: string,
+  state: string,
+  options: SettingOptions | undefined,
+): Promise<Record<string, unknown> | void> {
+  const action = parsePermissionAction(state);
+  const target = parseAndroidPermissionTarget(options?.permissionTarget, options?.permissionMode);
+  if (action === 'grant') {
+    await grantAndroidPermission(device, appPackage, target);
+    return;
+  }
+  const grantedBefore = await readAndroidGrantedRuntimePermissions(device, appPackage);
+  const permission = await revokeAndroidPermission(device, appPackage, action, target);
+  const wasGranted = grantedBefore.has(permission);
+  return {
+    permission,
+    wasGranted,
+    ...(wasGranted
+      ? { warnings: [androidRevokedGrantedPermissionWarning(appPackage, permission)] }
+      : {}),
+  };
+}
+
+async function grantAndroidPermission(
+  device: DeviceInfo,
+  appPackage: string,
+  target: AndroidPermissionTarget,
+): Promise<void> {
+  if (target.kind === 'notifications') {
+    await setAndroidNotificationPermission(device, appPackage, 'grant', target);
+  } else if (target.type === 'photos') {
+    await setAndroidPhotoPermission(device, appPackage, 'grant');
+  } else {
+    await runAndroidAdb(device, ['shell', 'pm', 'grant', appPackage, target.value]);
+  }
+}
+
+/** Revokes (and for `reset`, clears the flags of) the target; returns the permission revoked. */
+async function revokeAndroidPermission(
+  device: DeviceInfo,
+  appPackage: string,
+  action: 'deny' | 'reset',
+  target: AndroidPermissionTarget,
+): Promise<string> {
+  if (target.kind === 'notifications') {
+    await setAndroidNotificationPermission(device, appPackage, action, target);
+    return target.permission;
+  }
+  let permission: string;
+  if (target.type === 'photos') {
+    permission = await setAndroidPhotoPermission(device, appPackage, 'revoke');
+  } else {
+    permission = target.value;
+    await runAndroidAdb(device, ['shell', 'pm', 'revoke', appPackage, permission]);
+  }
+  if (action === 'reset') await clearAndroidPermissionFlags(device, appPackage, permission);
+  return permission;
+}
+
+/**
+ * Runtime permissions `dumpsys package <pkg>` reports as `granted=true`. Best-effort: a
+ * failed or unparseable dump reads as "nothing granted", which only costs the warning.
+ */
+async function readAndroidGrantedRuntimePermissions(
+  device: DeviceInfo,
+  appPackage: string,
+): Promise<ReadonlySet<string>> {
+  const result = await runAndroidAdb(device, ['shell', 'dumpsys', 'package', appPackage], {
+    allowFailure: true,
+  });
+  if (result.exitCode !== 0) return new Set();
+  return parseAndroidGrantedRuntimePermissions(result.stdout);
+}
+
+export function parseAndroidGrantedRuntimePermissions(dumpsysOutput: string): ReadonlySet<string> {
+  const granted = new Set<string>();
+  for (const match of dumpsysOutput.matchAll(/^\s*([\w.]+): granted=true\b/gm)) {
+    granted.add(match[1]!);
+  }
+  return granted;
+}
+
 type AndroidFingerprintAction = 'match' | 'nonmatch';
 
 function parseAndroidFingerprintAction(state: string): AndroidFingerprintAction {
 
@@ -673,6 +673,7 @@ agent-device settings permission reset screen-recording --platform macos
 - On macOS, `settings permission grant ...` checks/request access and opens System Settings guidance when needed; it does not silently grant TCC permissions.
 - On macOS, `settings permission deny ...` is intentionally unsupported.
 - Android uses `pm grant|revoke` for runtime permissions (`reset` maps to revoke) and `appops` for notifications.
+- Android kills the app process whenever a runtime permission it currently holds is revoked, so `settings permission deny|reset` after a grant leaves the session app not running. The response then carries `wasGranted: true` and a warning; relaunch with `open <app> --relaunch` before the next interaction. Revoking a permission the app does not hold is harmless.
 - `full|limited` mode is supported only for iOS `photos`; other targets reject mode.
 - Use `match`/`nonmatch` to simulate valid/invalid Face ID, Touch ID, and Android fingerprint outcomes.