@@ -2,6 +2,10 @@ import path from 'node:path';
 import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 import type { DaemonResponse } from '@agent-device/kernel/contracts';
 import type { DeviceInfo } from '@agent-device/kernel/device';
+import {
+  acquireDeviceClaim,
+  inspectDeviceClaims,
+} from '@agent-device/daemon-contracts/device-claims';
 import type {
   LaunchConfirmationAbsent,
   LaunchConfirmationOutcome,
@@ -18,7 +22,9 @@ import type { DaemonRequest } from '../../../core/daemon-request.ts';
 import type { SessionState } from '../../../core/session-state.ts';
 import { refFrameState } from '../../../core/ref-frame.ts';
 import { installProviderDeviceAdmission } from '../../../core/provider-device-admission.ts';
+import { isDaemonIdle } from '../../server/daemon-idle-reap.ts';
 import { daemonPlatformServicesFixture } from '../../../__tests__/support/platform-services-fixture.ts';
+import { lifecycleOperationsSpy } from '../../../__tests__/support/lifecycle-operations-spy.ts';
 import { fakeCreateCommandSurface } from '../../../__tests__/support/command-surface-fake.ts';
 import {
   handleSessionCommands,
@@ -189,6 +195,98 @@ test('open --relaunch leaves the old frame expired when the lifecycle fails (ADR
   expect(refFrameState(sessionStore.get('android-session')!)).toBe('expired');
 });
 
+test('failed relaunch retains the claim for close while allowing daemon idle reap', async () => {
+  const claimsDir = mkdtempForTestSync('relaunch-claims-');
+  const previousClaimsDir = process.env.AGENT_DEVICE_CLAIMS_DIR;
+  process.env.AGENT_DEVICE_CLAIMS_DIR = claimsDir;
+  try {
+    const sessionStore = makeSessionStore();
+    const sessionName = 'android-session';
+    const acquired = await acquireDeviceClaim({
+      env: process.env,
+      device: ANDROID_EMULATOR,
+      session: sessionName,
+      workspace: process.cwd(),
+      stateDir: sessionStore.resolveDaemonStateDir(),
+      reconcileOrphanedDeviceClaim: async () => ({
+        status: 'retained',
+        reason: 'test-no-recovery',
+      }),
+    });
+    if (acquired.status !== 'acquired') throw new Error('claim was not acquired');
+    publishSession(sessionStore, sessionName, ANDROID_EMULATOR, {
+      deviceClaim: acquired.ownership,
+    });
+    const claims = () => inspectDeviceClaims({ serial: ANDROID_EMULATOR.id }, process.env);
+    expect(isDaemonIdle({ sessionStore, inFlightRequestCount: 0 })).toBe(false);
+
+    await expect(
+      openRelaunch({
+        sessionStore,
+        sessionName,
+        onOpenApplication: () => {
+          throw new Error('lifecycle dispatch failed');
+        },
+      }),
+    ).rejects.toThrow('lifecycle dispatch failed');
+    expect(sessionStore.get(sessionName)).toMatchObject({
+      name: sessionName,
+      deviceClaim: acquired.ownership,
+    });
+    expect(claims()[0]?.claim?.session).toBe(sessionName);
+    expect(isDaemonIdle({ sessionStore, inFlightRequestCount: 0 })).toBe(true);
+
+    expect((await openRelaunch({ sessionStore, sessionName })).response?.ok).toBe(true);
+    expect(isDaemonIdle({ sessionStore, inFlightRequestCount: 0 })).toBe(false);
+    await expect(
+      openRelaunch({
+        sessionStore,
+        sessionName,
+        onOpenApplication: () => {
+          throw new Error('lifecycle dispatch failed again');
+        },
+      }),
+    ).rejects.toThrow('lifecycle dispatch failed again');
+
+    const { loader } = lifecycleOperationsSpy();
+    const closed = await handleSessionCommands({
+      host: createTestHostEnvironment(),
+      createCommandSurface: fakeCreateCommandSurface,
+      platformServices: daemonPlatformServicesFixture(),
+      lifecycleOperationsLoader: loader,
+      req: { token: 't', session: sessionName, command: 'close', positionals: [], flags: {} },
+      sessionName,
+      logPath: path.join(mkdtempForTestSync('daemon'), 'daemon.log'),
+      sessionStore,
+      invoke: noopInvoke,
+    });
+    expect(closed?.ok).toBe(true);
+    expect(sessionStore.get(sessionName)).toBeUndefined();
+    expect(claims()).toEqual([]);
+    mockResolveTargetDevice.mockResolvedValue(ANDROID_EMULATOR);
+    const reopened = await openRelaunch({
+      sessionStore,
+      sessionName,
+      positionals: ['com.example.app'],
+      flags: { platform: 'android' },
+    });
+    expect(reopened.response?.ok).toBe(true);
+    expect(claims()[0]?.claim?.session).toBe(sessionName);
+  } finally {
+    if (previousClaimsDir === undefined) delete process.env.AGENT_DEVICE_CLAIMS_DIR;
+    else process.env.AGENT_DEVICE_CLAIMS_DIR = previousClaimsDir;
+  }
+});
+
+test('relaunch rejected before dispatch still keeps the daemon active', async () => {
+  const sessionStore = makeSessionStore();
+  publishSession(sessionStore, 'android-session', ANDROID_EMULATOR, { appName: undefined });
+  const { response, opened } = await openRelaunch({ sessionStore, sessionName: 'android-session' });
+  expect(response?.ok).toBe(false);
+  expect(opened).toEqual([]);
+  expect(isDaemonIdle({ sessionStore, inFlightRequestCount: 0 })).toBe(false);
+});
+
 test('open --relaunch does not let an ambient provider claim suppress the relaunch', async () => {
   const sessionStore = makeSessionStore();
   installProviderDeviceAdmission({ isActive: (device) => device.id === ANDROID_EMULATOR.id });
 
@@ -281,26 +281,33 @@ export async function completeOpenCommand(params: {
     ? sessionStore.requireCurrent(openDispatchRef)
     : undefined;
   const openStartedAtMs = Date.now();
-  const outcome = await lifecycle.operations.openApplication({
-    target: openTarget,
-    positionals: openPositionals,
-    outPath: req.flags?.out,
-    runtimeLaunchUrl: runtimeHints?.launchUrl,
-    appBundleId: sessionAppBundleId,
-    surface,
-    hasExistingSession: existingSession !== undefined,
-    relaunch: shouldRelaunch,
-    prewarmRunnerBeforeOpen: req.flags?.maestro?.prewarmRunnerBeforeOpen === true,
-    enableTestIme: shouldActivateAndroidTestIme(device, req),
-    stateDir: sessionStore.resolveDaemonStateDir(),
-    runtimeHints: runtimeHintValues(runtimeHints),
-    applyRuntimeHints,
-    execution: applicationLifecycleExecutionFromRequest(
-      req,
-      logPath,
-      openDispatchSession?.trace?.outPath,
-    ),
-  });
+  const outcome = await lifecycle.operations
+    .openApplication({
+      target: openTarget,
+      positionals: openPositionals,
+      outPath: req.flags?.out,
+      runtimeLaunchUrl: runtimeHints?.launchUrl,
+      appBundleId: sessionAppBundleId,
+      surface,
+      hasExistingSession: existingSession !== undefined,
+      relaunch: shouldRelaunch,
+      prewarmRunnerBeforeOpen: req.flags?.maestro?.prewarmRunnerBeforeOpen === true,
+      enableTestIme: shouldActivateAndroidTestIme(device, req),
+      stateDir: sessionStore.resolveDaemonStateDir(),
+      runtimeHints: runtimeHintValues(runtimeHints),
+      applyRuntimeHints,
+      execution: applicationLifecycleExecutionFromRequest(
+        req,
+        logPath,
+        openDispatchSession?.trace?.outPath,
+      ),
+    })
+    .catch((error: unknown) => {
+      if (existingRef && shouldRelaunch && sessionStore.resolveCurrent(existingRef)) {
+        sessionStore.markCloseEffectsUnconfirmed(existingRef);
+      }
+      throw error;
+    });
   sessionAppBundleId = outcome.appBundleId ?? sessionAppBundleId;
   const timing: OpenTiming = { ...outcome.timing };
   const preparedSelection = markSelectionBootOccurred(selection);
 
@@ -408,6 +408,7 @@ Android physical-device prerequisites:
 
 Runner and daemon lifecycle (applies to simulators too):
   open without --relaunch is idempotent-foreground for an already-running app, except native macOS app opens keep it in the background (help macos); neither restarts the process. open --relaunch restarts the app; on iOS simulators this collapses to one simctl launch --terminate-running-process call instead of a separate terminate-then-launch.
+  If an existing session's relaunch fails after dispatch, close can release its device claim. The session does not keep an idle daemon alive until a successful open.
   No runner read launches a session app that is not running: snapshot, wait, is, get, a reading find, and an interaction's leading reads (a gesture's viewport read, the capture that resolves a selector click/fill) answer the retriable APP_NOT_RUNNING instead of bare-launching over a launch SpringBoard still holds behind its deep-link confirmation. Only open, activate, and a command that mutates without a leading read bring a stopped app up.
   close keeps a healthy iOS simulator XCTest runner warm by default so the next open on that simulator (same udid in the same simulator set) skips the runner build, unless --shutdown was requested, the session was recording, or its device lease ends on close. A lease allocated with retainOnClose can keep the runner between sessions; releasing or expiring that lease stops its runner unless a session outside the lease has taken over the device. A retained runner auto-stops after an idle window (default 5 minutes); set AGENT_DEVICE_IOS_RUNNER_IDLE_STOP_MS to override, or 0 to disable idle stopping. Lease release, expiry, and graceful daemon shutdown still clean up runners they own. Only a ready runner with an observed listener is retained; close retires unfinished prewarm recovery. Losing the retained listener stops that generation, and graceful daemon shutdown stops idle retained runners rather than handing them off without supervision.
   Each AGENT_DEVICE_STATE_DIR runs its own daemon. It self-exits after an idle window (default 5 minutes, matching the runner idle-stop default) once it has no open sessions, no in-flight requests, and no active recording; set AGENT_DEVICE_DAEMON_IDLE_TIMEOUT_MS to override, or 0 to disable idle reap.
 
@@ -105,6 +105,7 @@ Open apps and links:
 - Android (adb): an intent target such as `open settings` records the package that opened as `appBundleId`. `open settings --relaunch` stops and restarts that app. If the intent matches more than one activity, `--relaunch` fails.
 - Android (ADB): `close` force-stops the app, then checks for 2 seconds that it has left the foreground, waits up to 10 seconds for the processes it killed to exit, and checks for 2 more that no new process started. If a check window ends first, `close` fails with `details.reason: android-app-close-timeout` and `details.phase` set to `foreground`, `exit`, or `process`; a process that survives the force-stop fails with `exit`, and apps Android restarts at once, such as the launcher, fail with `process`. When `pidof` cannot list the app's processes, `close` fails with `details.reason: android-process-probe-unavailable`; if that happens before the force-stop, the app keeps running.
 - When `close` cannot confirm its cleanup on a session that holds a device claim, it fails and keeps the session and its claim, so the device is not handed on unconfirmed. Run `close` again with the same options to retry the cleanup and release the device, leaving out `--save-script` once the first attempt has published the script. Only `close`, or a successful `open`, is supported on the kept session: other commands work, but the session stays marked, so an idle daemon can still shut it down. If nobody retries, the kept session does not keep the daemon alive: when the daemon has been idle for its idle timeout and shuts down, its shutdown retries the cleanup, and a claim it still cannot confirm goes stale instead of being released. Embedded runtimes and `AGENT_DEVICE_DAEMON_IDLE_TIMEOUT_MS=0` never shut down for idleness, so there a retried `close` is the only release.
+- If `open --relaunch` fails after it starts on an existing session, the session and its claim remain available for `close`. The session does not keep an idle daemon alive until a successful `open`.
 
 iOS Simulator launch behavior: