@@ -5,9 +5,13 @@ import type { EncodedDurableDescriptor } from '@agent-device/contracts/durable-r
 import { deviceIdentity, type DeviceInfo } from '@agent-device/kernel/device';
 import {
   cleanupAndroidPerfCaptureDescriptor,
+  cleanupApplePerfCaptureDescriptor,
   inspectAndroidPerfCaptureDescriptor,
+  inspectApplePerfCaptureDescriptor,
   startAndroidPerfCapture,
+  startApplePerfCapture,
 } from './platform-runtime-perf-capture-host.ts';
+import { IOS_SIMULATOR } from './__tests__/test-utils/device-fixtures.ts';
 
 const androidNative = vi.hoisted(() => ({
   startAndroidSimpleperfProfile: vi.fn(),
@@ -17,7 +21,21 @@ const androidNative = vi.hoisted(() => ({
   cleanupAndroidNativePerfSession: vi.fn(),
 }));
 
+const appleXctrace = vi.hoisted(() => ({
+  startAppleXctracePerfCapture: vi.fn(),
+  stopAppleXctracePerfCapture: vi.fn(),
+  cleanupAppleXctracePerfCapture: vi.fn(),
+}));
+
+const processHost = vi.hoisted(() => ({
+  resolveManagedProcessIdentity: vi.fn(),
+  inspectManagedProcess: vi.fn(),
+  terminateManagedProcessSet: vi.fn(),
+}));
+
 vi.mock('@agent-device/platform-android/mechanics', () => androidNative);
+vi.mock('@agent-device/platform-apple/perf', () => appleXctrace);
+vi.mock('./platform-runtime-screen-recording-process-host.ts', () => processHost);
 
 const device: DeviceInfo = {
   platform: 'android',
@@ -28,9 +46,22 @@ const device: DeviceInfo = {
   booted: true,
 };
 
+const appleDevice = IOS_SIMULATOR;
+
+const appleMarker = Object.freeze({
+  pid: 4210,
+  startTime: 'Fri Oct 02 09:00:00 2026',
+  command: 'xcrun xctrace record --template Time Profiler',
+});
+
 beforeEach(() => {
   vi.clearAllMocks();
   androidNative.cleanupAndroidNativePerfSession.mockResolvedValue(undefined);
+  appleXctrace.cleanupAppleXctracePerfCapture.mockResolvedValue({
+    code: 0,
+    stdout: '',
+    stderr: '',
+  });
 });
 
 test('accepts only a fully decoded Android native capture descriptor', async () => {
@@ -153,6 +184,275 @@ test('starts and finishes an Android Perfetto trace', async () => {
   );
 });
 
+test('starts, retargets, stops, and reclaims an Apple xctrace capture through one live handle', async () => {
+  const capture = appleCapture({ mode: 'trace', template: 'Animation Hitches' });
+  appleXctrace.startAppleXctracePerfCapture.mockResolvedValue(capture);
+  appleXctrace.stopAppleXctracePerfCapture.mockImplementation(
+    async (current: typeof capture, outPath: string) => ({
+      ...stripAppleChild(current),
+      outPath,
+      endedAt: '2026-10-02T09:01:00.000Z',
+    }),
+  );
+  processHost.resolveManagedProcessIdentity.mockResolvedValue(appleMarker);
+  processHost.inspectManagedProcess.mockReturnValue('owned-alive');
+  processHost.terminateManagedProcessSet.mockResolvedValue('terminated');
+
+  const started = await startApplePerfCapture(
+    appleDevice,
+    localRuntimeOwner('apple'),
+    captureInput({ kind: 'xctrace', mode: 'trace', template: 'Animation Hitches' }),
+  );
+  expect(appleXctrace.startAppleXctracePerfCapture).toHaveBeenCalledWith({
+    device: appleDevice,
+    appBundleId: 'com.example.app',
+    mode: 'trace',
+    template: 'Animation Hitches',
+    outPath: '/tmp/capture',
+  });
+  expect(started.response).toMatchObject({ perf: 'started', kind: 'xctrace', mode: 'trace' });
+
+  const handle = started.pendingHandle.transfer();
+  handle.setOutputPath('/tmp/retargeted.trace');
+  await expect(handle.finish()).resolves.toMatchObject({
+    status: 'completed',
+    result: { perf: 'stopped', outPath: '/tmp/retargeted.trace', endedAt: expect.any(String) },
+  });
+
+  await expect(inspectApplePerfCaptureDescriptor(started.envelope)).resolves.toEqual({
+    status: 'unreattachable',
+    reason: 'transport-not-reattachable',
+  });
+  await expect(cleanupApplePerfCaptureDescriptor(started.envelope)).resolves.toEqual({
+    status: 'cleaned',
+  });
+  expect(processHost.terminateManagedProcessSet).toHaveBeenCalledWith([appleMarker]);
+});
+
+test('derives the xctrace template from the capture mode', async () => {
+  appleXctrace.startAppleXctracePerfCapture.mockResolvedValue(
+    appleCapture({ mode: 'cpu-profile', template: 'Time Profiler' }),
+  );
+  processHost.resolveManagedProcessIdentity.mockResolvedValue(appleMarker);
+
+  await startApplePerfCapture(
+    appleDevice,
+    localRuntimeOwner('apple'),
+    captureInput({ kind: 'xctrace', mode: 'cpu-profile' }),
+  );
+  expect(appleXctrace.startAppleXctracePerfCapture).toHaveBeenLastCalledWith(
+    expect.objectContaining({ template: 'Time Profiler' }),
+  );
+
+  await startApplePerfCapture(
+    appleDevice,
+    localRuntimeOwner('apple'),
+    captureInput({ kind: 'xctrace', mode: 'trace' }),
+  );
+  expect(appleXctrace.startAppleXctracePerfCapture).toHaveBeenLastCalledWith(
+    expect.objectContaining({ template: 'Animation Hitches' }),
+  );
+});
+
+test('rejects a non-xctrace native kind for an Apple capture', async () => {
+  await expect(
+    startApplePerfCapture(
+      appleDevice,
+      localRuntimeOwner('apple'),
+      captureInput({ kind: 'perfetto', mode: 'trace' }),
+    ),
+  ).rejects.toThrow('Apple native perf requires --kind xctrace, not perfetto');
+  expect(appleXctrace.startAppleXctracePerfCapture).not.toHaveBeenCalled();
+});
+
+test('reclaims the profiler when Apple exposes no exact process identity', async () => {
+  const capture = appleCapture({ mode: 'cpu-profile', template: 'Time Profiler' });
+  appleXctrace.startAppleXctracePerfCapture.mockResolvedValue({
+    ...capture,
+    child: { pid: undefined },
+  });
+  processHost.resolveManagedProcessIdentity.mockResolvedValue(undefined);
+
+  await expect(
+    startApplePerfCapture(
+      appleDevice,
+      localRuntimeOwner('apple'),
+      captureInput({ kind: 'xctrace', mode: 'cpu-profile' }),
+    ),
+  ).rejects.toThrow('Apple xctrace exposed no exact process identity');
+  expect(processHost.resolveManagedProcessIdentity).toHaveBeenCalledWith(undefined);
+  expect(appleXctrace.cleanupAppleXctracePerfCapture).toHaveBeenCalledTimes(1);
+});
+
+test('maps each managed-process outcome through Apple descriptor cleanup', async () => {
+  const envelope = appleEnvelope();
+  const cases: Array<
+    Readonly<{
+      ownership: 'ownership-lost' | 'missing' | 'owned-alive';
+      terminated?: 'terminated' | 'already-missing' | 'ownership-lost';
+      expected: { status: string; reason?: string };
+    }>
+  > = [
+    {
+      ownership: 'ownership-lost',
+      expected: { status: 'cleanup-pending', reason: 'ownership-fence-lost' },
+    },
+    { ownership: 'missing', expected: { status: 'already-missing' } },
+    {
+      ownership: 'owned-alive',
+      terminated: 'terminated',
+      expected: { status: 'cleaned' },
+    },
+    {
+      ownership: 'owned-alive',
+      terminated: 'already-missing',
+      expected: { status: 'already-missing' },
+    },
+    {
+      ownership: 'owned-alive',
+      terminated: 'ownership-lost',
+      expected: { status: 'cleanup-pending', reason: 'ownership-fence-lost' },
+    },
+  ];
+  for (const testCase of cases) {
+    processHost.inspectManagedProcess.mockReturnValueOnce(testCase.ownership);
+    if (testCase.terminated !== undefined) {
+      processHost.terminateManagedProcessSet.mockResolvedValueOnce(testCase.terminated);
+    }
+    await expect(cleanupApplePerfCaptureDescriptor(envelope)).resolves.toEqual(testCase.expected);
+  }
+  expect(processHost.terminateManagedProcessSet).toHaveBeenCalledTimes(3);
+});
+
+test('maps each managed-process outcome through Apple descriptor reattach', async () => {
+  const envelope = appleEnvelope();
+  processHost.inspectManagedProcess
+    .mockReturnValueOnce('missing')
+    .mockReturnValueOnce('owned-alive')
+    .mockReturnValueOnce('ownership-lost');
+  await expect(inspectApplePerfCaptureDescriptor(envelope)).resolves.toEqual({
+    status: 'missing',
+  });
+  await expect(inspectApplePerfCaptureDescriptor(envelope)).resolves.toEqual({
+    status: 'unreattachable',
+    reason: 'transport-not-reattachable',
+  });
+  await expect(inspectApplePerfCaptureDescriptor(envelope)).resolves.toEqual({
+    status: 'unreattachable',
+    reason: 'ownership-fence-lost',
+  });
+});
+
+test('refuses Apple descriptor recovery for an undecodable or foreign body', async () => {
+  const malformed = [
+    { ...appleBody(), capture: 'not-a-capture' },
+    { ...appleBody(), capture: { ...appleBody().capture, kind: 'perfetto' } },
+    { ...appleBody(), capture: { ...appleBody().capture, mode: 'time' } },
+    {
+      ...appleBody(),
+      capture: (() => {
+        const { template: _template, ...capture } = appleBody().capture;
+        return capture;
+      })(),
+    },
+    { ...appleBody(), capture: { ...appleBody().capture, platform: 'apple' } },
+    { ...appleBody(), capture: { ...appleBody().capture, targetProcesses: [42] } },
+    { ...appleBody(), capture: { ...appleBody().capture, targetPids: ['12'] } },
+    { ...appleBody(), marker: { pid: 1 } },
+  ];
+  for (const body of malformed) {
+    await expect(inspectApplePerfCaptureDescriptor(envelope(body))).resolves.toMatchObject({
+      status: 'unreattachable',
+      reason: 'descriptor-invalid',
+    });
+    await expect(cleanupApplePerfCaptureDescriptor(envelope(body))).resolves.toEqual({
+      status: 'cleanup-pending',
+      reason: 'manual-recovery-required',
+    });
+  }
+
+  const androidBody = {
+    family: 'android',
+    capture: {
+      type: 'trace',
+      kind: 'perfetto',
+      packageName: 'com.example.app',
+      appPid: '101',
+      profilerPid: '202',
+      remotePath: '/data/misc/perfetto-traces/app.trace',
+      outPath: '/tmp/app.trace',
+      startedAt: 1,
+      state: 'running',
+    },
+  };
+  await expect(inspectApplePerfCaptureDescriptor(envelope(androidBody))).resolves.toEqual({
+    status: 'unreattachable',
+    reason: 'descriptor-invalid',
+  });
+  await expect(cleanupApplePerfCaptureDescriptor(envelope(androidBody))).resolves.toEqual({
+    status: 'cleanup-pending',
+    reason: 'manual-recovery-required',
+  });
+
+  processHost.inspectManagedProcess.mockReturnValue('missing');
+  await expect(
+    inspectApplePerfCaptureDescriptor(
+      envelope({ ...appleBody(), capture: { ...appleBody().capture, mode: 'trace' } }),
+    ),
+  ).resolves.toEqual({ status: 'missing' });
+});
+
+function appleCapture(input: {
+  mode: 'cpu-profile' | 'trace';
+  template: string;
+}): import('@agent-device/platform-apple/perf').AppleXctracePerfCapture {
+  return {
+    kind: 'xctrace',
+    ...input,
+    outPath: '/tmp/capture',
+    appBundleId: 'com.example.app',
+    deviceId: appleDevice.id,
+    platform: 'ios',
+    targetPids: [42],
+    targetProcesses: ['com.example.app'],
+    startedAt: '2026-10-02T09:00:00.000Z',
+    child: { pid: appleMarker.pid } as unknown as AppleChild,
+    wait: Promise.resolve({ code: 0, stdout: '', stderr: '' }),
+  } as unknown as import('@agent-device/platform-apple/perf').AppleXctracePerfCapture;
+}
+
+type AppleChild = import('@agent-device/platform-apple/perf').AppleXctracePerfCapture['child'];
+
+function stripAppleChild(
+  capture: import('@agent-device/platform-apple/perf').AppleXctracePerfCapture,
+) {
+  const { child: _child, wait: _wait, ...rest } = capture;
+  return rest;
+}
+
+function appleBody() {
+  return {
+    family: 'apple',
+    marker: { ...appleMarker },
+    capture: {
+      kind: 'xctrace',
+      mode: 'cpu-profile',
+      template: 'Time Profiler',
+      outPath: '/tmp/capture.trace',
+      appBundleId: 'com.example.app',
+      deviceId: appleDevice.id,
+      platform: 'ios',
+      targetPids: [42],
+      targetProcesses: ['com.example.app'],
+      startedAt: '2026-10-02T09:00:00.000Z',
+    },
+  };
+}
+
+function appleEnvelope() {
+  return envelope(appleBody());
+}
+
 function androidCapture(input: { kind: 'simpleperf' | 'perfetto'; type: 'cpu-profile' | 'trace' }) {
   return {
     action: 'start' as const,
@@ -169,7 +469,11 @@ function androidCapture(input: { kind: 'simpleperf' | 'perfetto'; type: 'cpu-pro
   };
 }
 
-function captureInput(input: { kind: 'simpleperf' | 'perfetto'; mode: 'cpu-profile' | 'trace' }) {
+function captureInput(input: {
+  kind: 'simpleperf' | 'perfetto' | 'xctrace';
+  mode: 'cpu-profile' | 'trace';
+  template?: string;
+}) {
   return {
     sessionId: 'one',
     appId: 'com.example.app',