@@ -22,6 +22,10 @@ vi.mock('../../../platforms/ios/perf-xctrace.ts', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../../platforms/ios/perf-xctrace.ts')>();
   return { ...actual, cleanupAppleXctracePerfCapture: vi.fn(async () => ({})) };
 });
+vi.mock('../../../platforms/android/perf.ts', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../platforms/android/perf.ts')>();
+  return { ...actual, cleanupAndroidNativePerfSession: vi.fn(async () => {}) };
+});
 vi.mock('../../../platforms/ios/macos-helper.ts', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../../platforms/ios/macos-helper.ts')>();
   return { ...actual, runMacOsAlertAction: vi.fn(async () => {}) };
@@ -44,10 +48,12 @@ import { teardownSessionResources } from '../session-close.ts';
 import { shutdownSimulator } from '../../../platforms/ios/simulator.ts';
 import { runCmd } from '../../../utils/exec.ts';
 import { cleanupAppleXctracePerfCapture } from '../../../platforms/ios/perf-xctrace.ts';
+import { cleanupAndroidNativePerfSession } from '../../../platforms/android/perf.ts';
 
 const mockShutdownSimulator = vi.mocked(shutdownSimulator);
 const mockRunCmd = vi.mocked(runCmd);
 const mockCleanupAppleXctracePerfCapture = vi.mocked(cleanupAppleXctracePerfCapture);
+const mockCleanupAndroidNativePerfSession = vi.mocked(cleanupAndroidNativePerfSession);
 
 const noopInvoke = async (_req: DaemonRequest): Promise<DaemonResponse> => ({ ok: true, data: {} });
 
@@ -291,6 +297,87 @@ test('daemon session teardown stops active Apple xctrace perf capture', async ()
   expect(session.applePerf?.active).toBeUndefined();
 });
 
+test('close stops active Android native perf capture before deleting session', async () => {
+  const sessionStore = makeSessionStore();
+  const sessionName = 'android-active-native-perf-session';
+  const activeCapture = {
+    type: 'trace',
+    kind: 'perfetto',
+    packageName: 'com.example.app',
+    appPid: '1234',
+    profilerPid: '5678',
+    remotePath: '/data/misc/perfetto-traces/app.perfetto-trace',
+    outPath: '/tmp/app.perfetto-trace',
+    startedAt: Date.now(),
+    state: 'running',
+  };
+  const session = {
+    ...makeSession(sessionName, {
+      platform: 'android',
+      id: 'emulator-5554',
+      name: 'Pixel',
+      kind: 'emulator',
+      booted: true,
+    }),
+    appBundleId: 'com.example.app',
+    nativePerf: {
+      android: activeCapture,
+    },
+  } as unknown as SessionState;
+  sessionStore.set(sessionName, session);
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'close',
+      positionals: [],
+      flags: {},
+    },
+    sessionName,
+    logPath: path.join(os.tmpdir(), 'daemon.log'),
+    sessionStore,
+    invoke: noopInvoke,
+  });
+
+  expect(response?.ok).toBe(true);
+  expect(mockCleanupAndroidNativePerfSession).toHaveBeenCalledWith(session.device, activeCapture);
+  expect(sessionStore.get(sessionName)).toBeUndefined();
+});
+
+test('daemon session teardown stops active Android native perf capture', async () => {
+  const sessionName = 'android-active-native-perf-teardown-session';
+  const activeCapture = {
+    type: 'cpu-profile',
+    kind: 'simpleperf',
+    packageName: 'com.example.app',
+    appPid: '1234',
+    profilerPid: '5678',
+    remotePath: '/data/local/tmp/cpu.perf.data',
+    outPath: '/tmp/cpu.perf.data',
+    startedAt: Date.now(),
+    state: 'running',
+  };
+  const session = {
+    ...makeSession(sessionName, {
+      platform: 'android',
+      id: 'emulator-5554',
+      name: 'Pixel',
+      kind: 'emulator',
+      booted: true,
+    }),
+    appBundleId: 'com.example.app',
+    nativePerf: {
+      android: activeCapture,
+    },
+  } as unknown as SessionState;
+
+  await teardownSessionResources(session, sessionName);
+
+  expect(mockCleanupAndroidNativePerfSession).toHaveBeenCalledWith(session.device, activeCapture);
+  expect(session.nativePerf?.android).toBeUndefined();
+});
+
 test('close --shutdown is ignored for Android devices', async () => {
   const sessionStore = makeSessionStore();
   const sessionName = 'android-device-shutdown-session';
 
@@ -8,6 +8,7 @@ import { SessionStore } from '../session-store.ts';
 import { stopAppLog } from '../app-log.ts';
 import { stopIosRunnerSession } from '../../platforms/ios/runner-client.ts';
 import { cleanupAppleXctracePerfCapture } from '../../platforms/ios/perf-xctrace.ts';
+import { cleanupAndroidNativePerfSession } from '../../platforms/android/perf.ts';
 import { clearRuntimeHintsFromApp, hasRuntimeTransportHints } from '../runtime-hints.ts';
 import { cleanupRetainedMaterializedPathsForSession } from '../materialized-path-registry.ts';
 import {
@@ -72,6 +73,13 @@ async function stopSessionApplePerfCapture(session: SessionState): Promise<void>
   session.applePerf = { ...(session.applePerf ?? {}), active: undefined };
 }
 
+async function stopSessionAndroidNativePerfCapture(session: SessionState): Promise<void> {
+  const active = session.nativePerf?.android;
+  if (!active) return;
+  await cleanupAndroidNativePerfSession(session.device, active);
+  session.nativePerf = { ...(session.nativePerf ?? {}), android: undefined };
+}
+
 export async function teardownSessionResources(
   session: SessionState,
   sessionName: string,
@@ -80,6 +88,7 @@ export async function teardownSessionResources(
     await stopAppLog(session.appLog);
   }
   await stopSessionApplePerfCapture(session);
+  await stopSessionAndroidNativePerfCapture(session);
   if (isApplePlatform(session.device.platform)) {
     await stopAppleRunnerForClose(session);
   }
@@ -101,6 +110,7 @@ export async function handleCloseCommand(params: {
     await stopAppLog(session.appLog);
   }
   await stopSessionApplePerfCapture(session);
+  await stopSessionAndroidNativePerfCapture(session);
   if (req.positionals && req.positionals.length > 0) {
     if (shouldStopAppleRunnerBeforeTargetedClose(session)) {
       await stopAppleRunnerForClose(session);
 
@@ -6,6 +6,7 @@ import { test } from 'vitest';
 import type { AndroidAdbExecutor } from '../adb-executor.ts';
 import {
   captureAndroidHeapSnapshot,
+  cleanupAndroidNativePerfSession,
   parseAndroidFramePerfSample,
   parseAndroidMemInfoSample,
   startAndroidPerfettoTrace,
@@ -443,6 +444,46 @@ test('stopAndroidSimpleperfProfile fails before pull when remote artifact never
   );
 });
 
+test('cleanupAndroidNativePerfSession stops profiler and removes remote artifact without pulling', async () => {
+  const session: AndroidNativePerfSession = {
+    type: 'trace',
+    kind: 'perfetto',
+    packageName: 'com.example.app',
+    appPid: '1234',
+    profilerPid: '8765',
+    remotePath: '/data/misc/perfetto-traces/app.perfetto-trace',
+    outPath: '/tmp/app.perfetto-trace',
+    startedAt: Date.now() - 1000,
+    state: 'running',
+  };
+  const calls: string[][] = [];
+  const adb: AndroidAdbExecutor = async (args) => {
+    calls.push(args);
+    if (args[0] === 'shell' && args[1]?.includes('kill -INT')) {
+      return { exitCode: 0, stdout: '', stderr: '' };
+    }
+    if (args[0] === 'shell' && args[1]?.includes('stat -c %s')) {
+      return { exitCode: 0, stdout: '5\n', stderr: '' };
+    }
+    if (args[0] === 'shell' && args[1]?.includes('rm -f')) {
+      return { exitCode: 0, stdout: '', stderr: '' };
+    }
+    if (args[0] === 'pull') {
+      throw new Error('cleanup must not pull artifacts');
+    }
+    throw new Error(`Unexpected adb call: ${args.join(' ')}`);
+  };
+
+  await cleanupAndroidNativePerfSession(ANDROID_EMULATOR, session, { adb });
+
+  assert.ok(findCallIndex(calls, 'kill -INT') < findCallIndex(calls, 'stat -c %s'));
+  assert.ok(findCallIndex(calls, 'rm -f') > findCallIndex(calls, 'stat -c %s'));
+  assert.equal(
+    calls.some((args) => args[0] === 'pull'),
+    false,
+  );
+});
+
 test('start and stop Android Perfetto trace use perfetto trace storage and cleanup remote artifact', async () => {
   const tmpDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'agent-device-perfetto-test-'));
   const outPath = path.join(tmpDir, 'app.perfetto-trace');
 
@@ -249,6 +249,22 @@ export async function stopAndroidPerfettoTrace(
   return await stopAndroidNativePerfSession(device, { ...session, outPath }, options);
 }
 
+export async function cleanupAndroidNativePerfSession(
+  device: DeviceInfo,
+  session: AndroidNativePerfSession,
+  options: AndroidNativePerfOptions = {},
+): Promise<void> {
+  const adb = resolveAndroidAdbExecutor(device, options.adb);
+  try {
+    if (session.state === 'running') {
+      await stopAndroidBackgroundTool(adb, session);
+      await waitForAndroidNativeArtifact(adb, session).catch(() => {});
+    }
+  } finally {
+    await cleanupAndroidRemotePath(adb, session.remotePath);
+  }
+}
+
 async function stopAndroidNativePerfSession(
   device: DeviceInfo,
   session: AndroidNativePerfSession,
 
@@ -16,6 +16,7 @@ export {
   type AndroidFramePerfSample,
 } from './perf-frame.ts';
 export {
+  cleanupAndroidNativePerfSession,
   startAndroidPerfettoTrace,
   startAndroidSimpleperfProfile,
   stopAndroidPerfettoTrace,
 
@@ -263,7 +263,7 @@ Additional CLI-backed methods are exposed on their domain groups with typed opti
 - `client.recording.record()` and `client.recording.trace()`
 - `client.settings.update()`
 
-`client.observability.perf()` returns daemon-shaped JSON so local and remote transports expose the same metrics payload. Pass `{ area: 'metrics' }` for the broad startup/CPU/memory/frame first pass, `{ area: 'frames' }` for a focused frame/jank-health payload, or `{ area: 'memory', action: 'sample' }` for a compact memory-only sample. Use `{ area: 'memory', action: 'snapshot', kind: 'android-hprof', out: 'app.hprof' }` on Android or `{ area: 'memory', action: 'snapshot', kind: 'memgraph', out: 'app.memgraph' }` on supported Apple simulator/macOS app sessions to write large memory artifacts to disk. Android native artifacts use `{ area: 'cpu', mode: 'profile', action: 'start' | 'stop' | 'report', kind: 'simpleperf', out }` and `{ area: 'trace', action: 'start' | 'stop', kind: 'perfetto', out }`; these Android-only commands return artifact paths and compact summaries, not trace/profile contents. Physical iOS device memgraph capture reports unavailable with a reason/hint. heapprofd allocation tracing is deferred until Perfetto plumbing is available. On Android and supported Apple targets, `data.metrics.fps.droppedFramePercent` is the primary frame-smoothness value. Android derives it from the current `adb shell dumpsys gfxinfo <package> framestats` window; connected iOS devices derive it from `xcrun xctrace` Animation Hitches for the active app process. Frame samples include `windowStartedAt`, `windowEndedAt`, and `worstWindows` so agents can correlate dropped-frame clusters with logs, network entries, and their own session actions. A successful Android read resets Android frame stats; `open <app>` resets the Android frame window too, so agents can call `perf({ area: 'frames' })`, perform a transition or gesture, then call it again to inspect that focused window. iOS simulator and macOS app sessions report frame health as unavailable rather than inventing FPS or dropped-frame values.
+`client.observability.perf()` returns daemon-shaped JSON so local and remote transports expose the same metrics payload. Pass `{ area: 'metrics' }` for the broad startup/CPU/memory/frame first pass, `{ area: 'frames' }` for a focused frame/jank-health payload, or `{ area: 'memory', action: 'sample' }` for a compact memory-only sample. Use `{ area: 'memory', action: 'snapshot', kind: 'android-hprof', out: 'app.hprof' }` on Android or `{ area: 'memory', action: 'snapshot', kind: 'memgraph', out: 'app.memgraph' }` on supported Apple simulator/macOS app sessions to write large memory artifacts to disk. Android native artifacts use `{ area: 'cpu', subject: 'profile', action: 'start' | 'stop' | 'report', kind: 'simpleperf', out }` and `{ area: 'trace', action: 'start' | 'stop', kind: 'perfetto', out }`; these Android-only commands return artifact paths and compact summaries, not trace/profile contents. Physical iOS device memgraph capture reports unavailable with a reason/hint. heapprofd allocation tracing is deferred until Perfetto plumbing is available. On Android and supported Apple targets, `data.metrics.fps.droppedFramePercent` is the primary frame-smoothness value. Android derives it from the current `adb shell dumpsys gfxinfo <package> framestats` window; connected iOS devices derive it from `xcrun xctrace` Animation Hitches for the active app process. Frame samples include `windowStartedAt`, `windowEndedAt`, and `worstWindows` so agents can correlate dropped-frame clusters with logs, network entries, and their own session actions. A successful Android read resets Android frame stats; `open <app>` resets the Android frame window too, so agents can call `perf({ area: 'frames' })`, perform a transition or gesture, then call it again to inspect that focused window. iOS simulator and macOS app sessions report frame health as unavailable rather than inventing FPS or dropped-frame values.
 
 For Apple native profiling, call `perf({ area: 'cpu', subject: 'profile', action: 'start', kind: 'xctrace', template: 'Time Profiler', out: 'app.trace' })`, then stop with the same trace path and write a compact report with `action: 'report'`. `area: 'trace'` supports xctrace templates such as `Animation Hitches`. Responses include artifact paths and compact metadata only.