@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Opening a macOS app by bundle identifier now waits briefly when the app is already running but not yet registered with LaunchServices — the case when a supervisor or dev script started it directly — and if registration arrives within that bounded window the open attaches to the running copy, so the session drives the app the caller started, with its arguments. A copy still unlisted when the window closes gets the plain `open` as before, which can still duplicate; the wait only bounds the race, it does not close it. Launching an app that is not running costs one extra LaunchServices lookup and one process-table read, plus one bundle-identifier read when app-shaped processes exist.
 - Limrun iOS snapshots no longer fail when the instance reports a numeric or boolean accessibility value (the system photo picker's tabs report `1`/`0`): the provider seam normalizes variant scalars to text, the way the Apple tree does. Limrun nodes now also publish `selected: true` for nodes carrying the `Selected` trait, so snapshot output and `selected:` selectors can tell a picked photo from an unpicked one.
 - `settings` refuses a setting the target does not serve before anything changes, with `UNSUPPORTED_OPERATION`, `settings <setting> is not supported on this device`, and the target's `error.details.reason` (such as `unsupported-platform-leaf`). This replaces the macOS `INVALID_ARGS` refusal and the Apple `setting-unsupported-on-leaf` reason, and now also covers settings that used to reach the device first, such as Android `reset-keychain` or Apple `animations`.
 - `settings` refuses, before touching the device, a state its setting does not accept (`Invalid <setting> state: …`), a permission action or mode its target does not take (such as `permission deny accessibility`), and a stray extra argument (such as `clear-app-state <app> <extra>`). The CLI and the daemon accept the same state spellings, in any casing or surrounding whitespace.
 
@@ -177,6 +177,11 @@ test('local Apple tool provider exposes macOS host operations as semantic method
   const calls: Array<[string, string[], string | undefined]> = [];
   const provider = createLocalAppleToolProvider({
     runCommand: async (cmd, args, options) => {
+      // The bundle open's LaunchServices registration probe is the seam's own read, asserted in
+      // host-provider-open.test.ts; this routing test only reports it as listing the bundle.
+      if (cmd === '/usr/bin/lsappinfo') {
+        return { exitCode: 0, stdout: 'ASN:0x0-0x1234-"Demo":\n', stderr: '' };
+      }
       calls.push([cmd, args, typeof options?.stdin === 'string' ? options.stdin : undefined]);
       if (cmd === 'pbpaste') {
         return { exitCode: 0, stdout: 'copied\r\n', stderr: '' };
 
@@ -18,6 +18,12 @@ export function createLocalAppleMacOsHostProvider(
 ): AppleMacOsHostProvider {
   return {
     openBundle: async (bundleId, url) => {
+      // Loaded on the first bundle open, not when this provider is constructed: the probe's host-kit
+      // reads stay off the Apple façades' eager closure (ADR 0019), and an open of an already-listed
+      // app is the common path that never needs them until `open` actually runs.
+      const { waitForLaunchServicesRegistration } =
+        await import('./launch-services-registration.ts');
+      await waitForLaunchServicesRegistration(runCommand, bundleId);
       await runCommand('open', buildMacOpenArgs(bundleId, url));
     },
     openTarget: async (target) => {