stim 1.23.1 → 1.25.0

package/dist/{guide-DYYEO3Wz.mjs → guide-DR0K0xW9.mjs}

@@ -1,8 +1,8 @@
-import { t as ANDROID_AVD_CONFIG_HELP } from "./settings-C7O8A6ZI.mjs";
-import { i as findProjectRoot$1 } from "./project-DhCtQWWU.mjs";
-import { h as RECENT_LAUNCH_MS } from "./eas-session-ledger-BQF9Yyy9.mjs";
-import { o as guideStatus, t as WATCHMAN_NESTED_WORKTREES } from "./doctor-watchman-iGBpC6KM.mjs";
-import "./status-watch-BHFasOZN.mjs";
+import { t as ANDROID_AVD_CONFIG_HELP } from "./settings-B5tCoq9N.mjs";
+import { i as findProjectRoot$1 } from "./project-BiC68mIp.mjs";
+import { h as RECENT_LAUNCH_MS } from "./eas-session-ledger-BMCA1gdO.mjs";
+import { o as guideStatus, t as WATCHMAN_NESTED_WORKTREES } from "./doctor-watchman-BovI1y3-.mjs";
+import "./status-watch-Bc2J4TZn.mjs";
 import { SETTINGS, SETTINGS_SCHEMA_URL, TUTORIAL_VERSION } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/guide/agent.ts
@@ -191,13 +191,15 @@ RULES DURING THE LOOP
 - For stale Metro transforms or file-map state, use stim start --reset-cache.
   It restarts only this app's verified owned Metro, preserving devices and other
   apps' caches. See guide lifecycle for reset scope.
-- Reload is not part of the normal workflow. Use stim reload on an owned local
-  simulator or emulator when an error screen remains after the fix, and on
+- Reload is not part of the normal workflow. Use stim reload when an error
+  screen remains after the fix on an owned local simulator or emulator, a
+  physical device (an EAS Simulator session when its app connects to Metro), and on
   Android after a failed first bundle load. It reloads JavaScript and never
   restarts the app. An iOS app whose first bundle failed never connects to
   Metro, so reload cannot reach it and says to use the device's own Reload
-  control. For a physical device that reached Metro, use agent-device metro
-  reload with the reported port. The detected iOS Local Network first-load
+  control. With no owned launch recorded, reload goes through this workspace's
+  Metro to the apps connected to it, so an app that never connected is not
+  reached. The detected iOS Local Network first-load
   remedy uses UI automation instead because that app never established a Metro
   connection.
 - A successful stim reload confirms that the request was sent, not that new
@@ -482,12 +484,14 @@ refuses with STIM_CLAIM_UNAVAILABLE instead of cancellation or timeout. The
 child cleanup error names the launcher PID; unverifiable processes and descendants are left
 untouched. On POSIX, a launcher that exited before identity capture can only finish
 successfully once its process group is proven gone.
-After a termination request, cleanup waits at most one second for a child to
-close. Overall cleanup has a 35 second budget, including temporary-worktree
+After a termination request, cleanup waits for a child to close, then for its
+process group to exit: each wait is 5 seconds times the host's load per CPU,
+from 5 to 15 seconds. Overall cleanup has a 35 second budget, including temporary-worktree
 removal; unfinished cleanup returns STIM_CLAIM_UNAVAILABLE and leaves unresolved
 resources in place. Credential refresh waits asynchronously and checks
 cancellation before writing.
 On Windows, report probes require the built-in Windows PowerShell for process-tree containment.
+A probe's time limit counts only the probe itself; PowerShell's startup and exit each have their own 30 second limit.
 
 requestMachineAccess({ ticket?, signal? }) requests build and device-host access
 from configured remote machines without granting capabilities or repairing project
@@ -642,9 +646,10 @@ STIM_CLAIM_UNAVAILABLE, taking precedence over cancellation or callback failure;
 follow its remedy before retrying. Startup never retries automatically.
 
 reload({ platform?, signal?, beforeReload? }) requests a JavaScript reload in
-the live iOS/Android app or reloads the owned Chrome page. It returns the flat
-stim reload --json facts: platform, deviceId, deviceName, appId, metroPort,
-strategy, targets and reverseRestored. Choose ios, android or web when more
+the live iOS/Android app (owned, on a physical device or in an EAS Simulator
+session) or reloads the owned Chrome page. It returns the flat
+stim reload --json facts: platform, deviceId, deviceName, appId (null for an
+app Stim did not launch), metroPort, strategy, targets and reverseRestored. Choose ios, android or web when more
 than one platform is live. A request does not prove completion; verify the UI
 and inspect logs. A Metro broadcast can reach other connected clients.
 beforeReload(workspace) runs once after resolving the workspace and before
@@ -802,8 +807,10 @@ warns when gh is unavailable.
 
 status's remoteDevices lists each environment's recorded EAS Simulator
 session. The session is billable while it runs, and it makes the environment
-live. status reads only local records; it does not ask EAS whether the session
-is still running.
+live. EAS stops it by itself after remote.easMaxDurationMinutes (default 30).
+status reads only local records; it does not ask EAS whether the session is
+still running, so a session EAS already stopped stays listed until the next
+run replaces it or stop clears it.
 
   remoteDevices   [{ platform, backend, sessionId, state, startedAt,
                   webPreviewUrl }], empty when the workspace has none
@@ -983,8 +990,10 @@ leased until <time>" for each one.`,
                     true         Metro finished the bundle response, or an app
                                  without Metro (a release build, or a native
                                  Xcode or Gradle app) has a live process; then
-                                 the app stayed alive through a three-second
-                                 stability window.
+                                 the app stayed alive until its JavaScript
+                                 reported \`Running "<name>"\` (plus half a
+                                 second), or through a three-second stability
+                                 window when it did not.
                                  The command checks process liveness when the
                                  platform exposes it. Errors from that window
                                  are printed even when the app stays alive,
@@ -996,12 +1005,14 @@ leased until <time>" for each one.`,
                                  bundle and the process, never a frame, and a
                                  cold app can keep rendering for a minute or
                                  more after this, which is why the stderr line
-                                 reads \`bundle loaded, process alive, stable
-                                 for 3s -- the first screen may still be
-                                 rendering\`. Poll the UI before you trust a
-                                 screenshot. Optional app-declared readiness
-                                 adds a separate stderr readiness phase; it
-                                 does not change this field. See
+                                 reads \`bundle loaded, process alive, app
+                                 JavaScript running -- the first screen may
+                                 still be rendering\` (\`stable for 3s\` when
+                                 no \`Running\` log arrived). Poll the UI
+                                 before you trust a screenshot. Optional
+                                 app-declared readiness adds a separate
+                                 stderr readiness phase; it does not change
+                                 this field. See
                                  \`guide lifecycle readiness\`
                     "bundling"   the request DID arrive and Metro was still
                                  building or delivering when the bundle timeout closed.
@@ -1013,6 +1024,15 @@ leased until <time>" for each one.`,
                                  finishing
                     "unverified" nothing was observed at all: usually a
                                  dev-client server picker awaiting a tap
+                  The wait for the app's bundle request is 20 seconds. On
+                  Expo, the dev client's manifest request (recorded in the
+                  metro log as manifest_request_started, _finished or _failed)
+                  counts as progress: the wait stays open while one is in
+                  flight and for 15 seconds after one was served, up to 60
+                  seconds after the launch, on any target (a new or adopted
+                  emulator already waits 60). A manifest is never launch
+                  evidence, so a launch that makes no bundle request is still
+                  "unverified". Bare React Native makes no manifest request.
                   Neither "bundling" nor "unverified" is reported for an app
                   whose process is gone when the bundle timeout closes: the
                   run fails as FATAL, "the app process exited", with the
@@ -1131,10 +1151,15 @@ leased until <time>" for each one.`,
 
   platform        "ios" | "android" | "web"
   deviceId        the exact owned simulator UDID or emulator serial targeted;
-                  for web, the owned Chrome's DevTools endpoint
-  deviceName      the owned simulator or AVD name; for web, the Chrome version
+                  for web, the owned Chrome's DevTools endpoint; metro:<port>
+                  when the apps were reached through Metro alone
+  deviceName      the owned simulator or AVD name; for web, the Chrome version;
+                  "EAS Simulator session <id>" or "devices connected to
+                  Metro" when reached through Metro alone
   appId           the live bundle id or Android package; for web, the URL the
-                  owned page was on when Stim sent the reload
+                  owned page was on when Stim sent the reload; null when no
+                  launch is recorded (a physical device or EAS Simulator
+                  session) and Stim reloaded the apps connected to Metro
   metroPort       the workspace's verified Metro port; for web, the reserved
                   Metro port or null
   strategy        how the reload was addressed.
@@ -1482,7 +1507,8 @@ RULES
                   buildLock, buildSlot, deviceLease, easSession, worktree,
                   cache, gradleVersion, tempLeftover (one "done" labelled
                   with the TMPDIR it cleared, plus a "kept" or "failed" per
-                  entry gc checked again or could not delete).
+                  entry gc checked again or could not delete), trash (the
+                  same, labelled with $STIM_HOME/trash).
                   label is a device, path or cache name; id is the UDID,
                   AVD name or path behind it, or null. Under --cache
                   parked, a "done" parkedDevice was erased and stays
@@ -1707,10 +1733,23 @@ RULES
                               kind is stim (stim-claim-*, stim-host-*,
                               stim-fakehome-*, stim-hosted-macos-*,
                               stim-server-*, stim-ws-* directories), xctrace
-                              (instruments*.ktrace) or jest (Jest's
+                              (instruments*.ktrace), swiftpm
+                              (TemporaryDirectory.* directories) or jest (Jest's
                               jest_<uid in base 36> cache, never deleted). deleteCount
                               is what --delete removes. null with STIM_HOME
                               set or any --cache scope
+    trash                   { root, entries: [{ path, worktree, removedAt,
+                              bytes, willDelete, kept }] } | null  ignored
+                              directories worktree remove moved out of a
+                              worktree into $STIM_HOME/trash before git
+                              removed it. bytes is null while a removal is
+                              deleting the entry. kept names the live or
+                              unresolved ownership claim, the missing or
+                              invalid trash.json, or the worktree that
+                              still exists, that keeps a directory;
+                              --delete deletes the rest, only remove-*
+                              entries with a valid trash.json. null when the
+                              trash is empty or under any --cache scope
     caches                  { name, dir, source, bytes, note, willEmpty,
                               emptySkipped, scopedEmpty }  alive, not
                               garbage; willEmpty marks the ones --delete
@@ -2292,7 +2331,9 @@ RULES
                  existed count their device time in prepare and install
 
   Only runs that record a last build are listed: a run that stops before
-  looking up a build, such as a bad flag, is not. Estimates (expectedMs) come from run statistics, not builds.
+  looking up a build, such as a bad flag, is not. A run that builds or reuses
+  an app and then fails at the device, install or launch step is listed as
+  failed with its error code. Estimates (expectedMs) come from run statistics, not builds.
 
   done and total are counts, not a completion fraction: a target or task
   can take a second or ten minutes, and cached work finishes instantly.
@@ -2683,7 +2724,11 @@ HOSTED IOS METRO
   ios --remote <machine> keeps Metro local and needs no start --remote.
   The supervisor watches private gateway requests in workspace state, binds
   only this machine's Tailscale address and accepts only the pinned hosting peer
-  with a per-session secret. The host's bridge is loopback-only. Port and secret
+  with a per-session secret. The host's bridge is loopback-only. For an Expo
+  dev client it listens on this machine's Metro port, which the dev server
+  writes into the manifest. ios --remote starts Metro on a port free on both
+  Macs; a running Metro or a pin on a port the host uses refuses the run before
+  the build. Port and secret
   stay in 0600 workspace state and never appear in status, JSON or logs.
   metro.tunnel and metro.publicUrl are ignored. Supervisor restart recreates
   the recorded gateway; stop or a stopped hosted session closes it. A recorded
@@ -2721,9 +2766,16 @@ TAILNET-ONLY METRO
 
 BUNDLE WARMUP
   After verifying Metro, \`stim ios\` and \`stim android\` prefetch the
-  platform's development bundle while native work continues. Expo supplies the
-  entry point and bundle options through its manifest; bare React Native uses
-  the standard index entry and development bundle options, including lazy loading.
+  platform's development bundle while native work continues. The prefetch
+  requests the URL of the app's most recent bundle request on that platform,
+  read from this workspace's metro log, so it matches the app's entry point
+  and options and does not ask Expo for its manifest. A recorded URL whose
+  entry file no longer exists under the project root or its ancestors is
+  skipped. Expo computes the
+  runtime version fingerprint for every manifest request. Without a recorded
+  request, Expo supplies the entry point and bundle options through its
+  manifest, and bare React Native uses the standard index entry and
+  development bundle options, including lazy loading.
   Warmup is enabled by default. Set optimizations.metroWarmup=false to disable
   it on the next ios/android command, using the machine or project settings.
   For custom entry points or bundle options, set metro.warmupUrl.ios and/or
@@ -2771,7 +2823,9 @@ REMOTE DEVICE BACKENDS
   are Apple silicon. The cache key ends in that architecture.
 
   The EAS backend needs eas-cli 21.6.0 or later and an account with EAS
-  Simulator access. An EAS session is billable. Stim prepares the app before
+  Simulator access. An EAS session is billable; Stim has EAS stop each session
+  it creates after remote.easMaxDurationMinutes (default 30), and a later run
+  replaces a session that expired. Stim prepares the app before
   it creates or reconnects the session, so a failed build starts no session
   and the install follows the connection directly. EAS does not inherit the
   proxy credentials. Always tear the session down: \`stop\`,
@@ -3220,6 +3274,10 @@ serve bounded log queries.
   the safe direction: a client redbox that Fast Refresh already fixed keeps
   being reported until the next launch.
 
+  RUN FAILURES. A run that builds or reuses an app and then fails before the app
+  is running adds one build record with event run_failed, its code and the
+  phase it failed in, so \`status\` and \`logs --errors\` agree.
+
   OUTPUT. Every logs command, including --errors and --follow, shows full captured
   error, component and native stacks, with no frame or message-length limit.
   --errors shows the first 20 matching error records, plus stack context.
@@ -3345,7 +3403,15 @@ they stay in the local logs. These records carry no tokens.
 
 WHAT WRITES WHAT
   maintenance.ndjson   workspace maintenance actions, failures and explaining skips
-  metro.ndjson         the bundler, in every supervisor mode
+  metro.ndjson         the bundler, in every supervisor mode. Stim's
+                       middleware adds one record per bundle request
+                       (bundle_response_started, _progress, _finished,
+                       _failed; _started carries the request's path and
+                       query as url, which the next warmup prefetches)
+                       and, on Expo, one per dev-client manifest
+                       request (manifest_request_started, _finished,
+                       _failed: debug level, with platform and requestId;
+                       launch verification reads them as progress)
   client.ndjson        in-app console logs and redboxes -- BARE PROJECTS ONLY.
                        In expo-child and command-child mode everything the
                        dev server prints lands in metro.ndjson with raw: true,
@@ -3557,6 +3623,10 @@ Branch on the code, never on the message.`,
   --system-image / --device-profile for Android when the offer names
   an unavailable choice. A session that exists stays recorded even if delivery
   fails: retry stim ios|android --remote <machine>, or run stim stop to reconcile it.
+  An Expo dev client whose running or pinned Metro port is in use on the host
+  refuses before the build: run stim stop, then stim ios --remote <machine>
+  without stim start, so Stim starts Metro on a port free on both Macs, or pin
+  one free on both Macs with metro.port or STIM_METRO_PORT.
   An unreachable stop keeps the placement; rerun stim stop when the host answers.
   To see why a host was slow or refused: stim logs --source placement (hosts checked and
   reason codes), stim logs --source build (remote_connect_failed, remote_request_failed),
@@ -3648,8 +3718,9 @@ Branch on the code, never on the message.`,
   \`pod install\` (iOS) or the gradle dependency sync (Android) failed. On iOS
   this runs only when Podfile.lock and Pods/Manifest.lock disagree, or Pods is
   absent -- which is exactly what a carried worktree produces.
-  WHICH POD COMMAND: when the project root has a Gemfile and a Gemfile.lock
-  that resolves cocoapods, pods go through bundler -- \`bundle check --dry-run\`,
+  WHICH POD COMMAND: Stim takes the nearest Gemfile from the directory pod
+  install runs in (ios/) up to the project root, as Bundler finds it. When its
+  Gemfile.lock resolves cocoapods, pods go through bundler -- \`bundle check --dry-run\`,
   then \`bundle install\` only when that reports missing gems, then \`bundle exec
   pod install\` -- so the CocoaPods the lockfile pins is the one that writes
   Podfile.lock. Everything else gets plain \`pod install\`: no Gemfile, a Gemfile
@@ -3748,8 +3819,13 @@ Branch on the code, never on the message.`,
   leaves room for. A project with react-native-gesture-handler 3, whose
   shared shadow nodes have the longest known object path, fits a root of at
   most 24 characters for an x86_64 Debug build and 21 for arm64-v8a; other
-  projects fit 51 and 48. Refused BEFORE Gradle
-  runs -- a cache hit still installs -- because the build would otherwise
+  projects fit 51 and 48. \`stim android\` on
+  an emulator, local or --remote <backend>, refuses before it starts Metro
+  or prepares the emulator, even when a cached build would have installed.
+  That early refusal is skipped for a physical or hosted device, an EAS
+  profile and when build machines are paired; a build that still runs here
+  is refused before Gradle runs, so a cache hit there still installs.
+  The build would otherwise
   fail deep inside ninja ("mkdir ... No such file or directory" or
   "Filename longer than 260 characters"). Move or clone the project under a
   short real path such as C:\\src\\<name> and run Stim there. A subst drive
@@ -3916,6 +3992,13 @@ Unlisted or unpaired names refuse at setup before consulting the cache, without
 a build record or failed-run stats. A listed paired name with a cache hit needs
 no build and does not contact the selected machine.
 
+A fingerprint-mismatch reason means the worker fingerprints the synced
+checkout differently. It names the sources that differ and the files pod
+install or prebuild rewrote there. Stim already sends the gitignored files the
+fingerprint reads, such as .env.local. Make the named input agree on both Macs,
+for example by committing the lockfile pod install rewrote there; pairing does
+not change it.
+
 Run stim doctor --fix to ask for build access if not paired. Check
 stim settings get remote.machines. A person on the worker approves this machine
 by running the stim-server setup command doctor --fix printed, with its ticket
@@ -3959,6 +4042,11 @@ Rerun with --remote-build auto for normal placement and local fallback, or
   copying for the same reason. A copy without a claim would be invisible to a
   refresh starting after it, allowing the source dependencies to change while
   they are read.
+  A report command such as \`gc\` reports it when it cannot confirm that a child
+  it started has stopped, typically on a machine under heavy load. The child is
+  left untouched. The remedy tells you what to check and which command to run
+  again, and when the run held ownership claims it lists the exact \`rm\`
+  command for each retained claim.
   Warm also reports this code for EACCES, EPERM, EROFS and ENOENT while taking a claim.
   The message names the claim path and original filesystem error. Restore write
   access to the existing claim store, checking parent permissions, symlink
@@ -4284,7 +4372,8 @@ so a Debug run on one is wired to a LAN origin instead of localhost.`,
   and \`adb devices\`, then retry after any other run finishes. Keep the AVD and
   its process locks while its state is unverified.
   On iOS a slow first boot is waited out for up to ten minutes while the
-  simulator reports Booting or Booted but bootstatus has not completed.
+  simulator reports Booting or Booted but bootstatus has not completed, and
+  then until SpringBoard has finished starting, which \`simctl launch\` needs.
   Booted alone does not end that wait. The failure names the udid and the wait.
   After boot, a process-spawn probe must finish within 30 seconds before
   installation. If it fails, the refusal includes observed host memory pressure
@@ -4457,14 +4546,19 @@ so a Debug run on one is wired to a LAN origin instead of localhost.`,
   proxy is selected. They never select the backend.`
 		},
 		STIM_REMOTE_EAS_UNAVAILABLE: {
-			summary: "--remote eas needs eas-cli 21.6.0 or later",
+			summary: "--remote eas needs eas-cli 21.6.0 or later and an Expo app linked to an EAS project",
 			body: () => `STIM_REMOTE_EAS_UNAVAILABLE
   \`--remote eas\` requires eas-cli 21.6.0 or later, the first release with
   the \`eas simulator:*\` commands Stim runs. Stim reads \`eas --version\` and
   refuses before any build or session work when eas-cli is missing, older, or
   reports no version. Upgrade it (\`npm install --global eas-cli@latest\`, or
   the project's eas-cli dependency). Proxy environment variables do not change
-  this selection and are not passed to EAS.`
+  this selection and are not passed to EAS.
+  It is also the code when EAS reports that the Expo app has no EAS project
+  (no extra.eas.projectId), so no session was created. Link the app with
+  \`eas init --id <project-id> --non-interactive\` or create a project with
+  \`eas init --account <account-name> --non-interactive\`, then rerun. Rerunning
+  \`stim ios\` or \`stim android\` without the link fails the same way.`
 		},
 		STIM_REMOTE_PLATFORM_MISMATCH: {
 			summary: "the recorded remote session belongs to the other platform; stop, then rerun",
@@ -4548,12 +4642,17 @@ so a Debug run on one is wired to a LAN origin instead of localhost.`,
 			aliases: ["STIM_RELOAD_UNOWNED", "STIM_RELOAD_PROBE_FAILED"],
 			body: () => `STIM_RELOAD_STOPPED / STIM_RELOAD_UNOWNED / STIM_RELOAD_PROBE_FAILED
   The recorded app is gone, its exact device is not live and owned by this
-  workspace, or simctl/adb could not prove the process exists. For web,
+  workspace, or Metro has no peer for the app and simctl/adb could not prove the
+  process exists (a probe that times out alone does not stop the reload). For web,
   STOPPED means no owned Chrome is running (run stim web) and PROBE_FAILED
   that its identity could not be verified. A bare reload picks the Chrome page
-  only when no native launch is recorded. No launch or
-  device lifecycle action is taken; follow the printed platform-command or
-  process-probe remedy.`
+  only when no native launch is recorded. Stim records launches only on owned
+  local simulators and emulators. With none recorded, reload asks this
+  workspace's Metro for its connected apps, which reaches an app on a physical
+  device (--device) or an EAS Simulator session; STOPPED then means no app is
+  connected to that Metro, so launch it or, for an Android phone, restore its
+  adb reverse. No launch or device lifecycle action is taken; follow the
+  printed platform-command or process-probe remedy.`
 		},
 		STIM_RELOAD_FAILED: {
 			summary: "the reload failed; the remedy differs by shape -- read it before acting",
@@ -4704,6 +4803,13 @@ captured"  (in metro.ndjson, bare RN)
   config -- lands THERE, not in supervisor.log). \`stim logs --errors\` has
   the full records. Fix that and run \`start\` again.
 
+  A bind error on the reserved port ("listen EADDRINUSE ... :<port>") means
+  another process, usually another Stim home, took the port after Stim chose
+  it. \`start\` releases that reservation, reserves another free port and
+  starts again, up to 3 attempts, and says so. A pinned metro.port and
+  \`--remote\` starts are not retried. When all attempts fail, run \`start\`
+  again.
+
   "Cannot reuse or replace the recorded supervisor: ..."
   A live record has no verifiable OS process identity, or the workspace and
   registry records disagree. Nothing new was started; the old process is
@@ -5332,10 +5438,12 @@ hosting Mac keeps Metro local through a private bridge; see hosted-ios. Step 2 r
 Metro while other work happens.
 
 Each time Stim boots an owned local simulator or emulator, it mutes it: iOS
-simulators to volume zero through Xcode's devicectl once SpringBoard has
-finished starting, because SpringBoard resets the volume while it starts, and
-Android 15 and later emulators to media volume zero. A device that is already
-running keeps its volume. Turn sound on for one device with Sound (iOS) or
+simulators to volume zero through Xcode's devicectl, and Android 15 and later
+emulators to media volume zero. The iOS mute runs after SimSlim has applied its
+profile and once SpringBoard has finished starting, because both a SimSlim
+reboot and SpringBoard's startup reset the volume. A device that is already
+running keeps its volume, except that SimSlim reboots a running simulator whose
+profile changed. Turn sound on for one device with Sound (iOS) or
 Media sound (Android) in its Stim Desktop options; the choice lasts until that
 device next boots. Android 14 and older images have no shell command that can
 set media volume, so startup warns, as it does whenever a mute is not
@@ -5348,16 +5456,25 @@ not part of the normal workflow. It is the explicit recovery path when Fast
 Refresh cannot clear the current screen, and on Android after a failed first
 bundle load. It reloads JavaScript and never restarts the app. Use \`stim
 reload ios\` or \`stim reload android\` to select a platform when both owned
-apps are live. For a physical device that reached Metro, use \`agent-device
-metro reload --metro-port <reported-port>\`. The detected iOS Local Network
+apps are live. With no owned launch recorded, it reloads the apps connected to
+this workspace's Metro, such as one on a physical device (--device); an
+Android phone needs its adb reverse. An app in an EAS Simulator session may not
+connect to Metro through the tunnel; then reload finds no app and the way to
+restart it is stim ios|android --remote eas.
+The detected iOS Local Network
 first-load remedy uses agent-device UI automation because no Metro peer exists
-yet. It never builds, installs, boots, or cold-launches. It acts only on a live
-app on this workspace's owned local simulator or emulator, and refuses release
-builds, stopped or unowned devices, a missing or foreign Metro, and an
-ambiguous no-platform request. Every reload goes over this workspace's Metro
+yet. It never builds, installs, boots, or cold-launches. It acts on a live app
+on this workspace's owned local simulator or emulator, or on the apps connected
+to this workspace's Metro, and refuses release builds, stopped or unowned
+devices, a missing or foreign Metro, and an ambiguous no-platform request. Every reload goes over this workspace's Metro
 websocket, on both platforms. It never reopens a development-client URL,
 because that restarts the app rather than reloading its JavaScript.
 
+Before sending, Stim checks that the app process exists. The iOS probe
+(\`simctl spawn launchctl list\`) waits 5 seconds, scaled up with host load to at
+most 30. When the device tool still does not answer, Stim sends the reload anyway;
+\`STIM_RELOAD_PROBE_FAILED\` is then reported only if Metro finds no peer for the app after the reload fails.
+
 An Android reload first lists \`adb reverse\` on each live owned emulator
 launched against this Metro and re-applies the Metro port's reverse where it is
 missing. adb ties a reverse to its transport, and a transport that drops and
@@ -5384,7 +5501,7 @@ dev menu.
 When Metro reports no peer for the app, Stim broadcasts a reload anyway before
 giving up, because matching is best-effort and an unmatched peer may still be
 this app. So verify the UI first: it may already have recovered. If it did not,
-retry: a client reconnects every 2 seconds, which is also this probe's timeout,
+retry: a client reconnects every 2 seconds, which is also the Metro probe's timeout,
 so a single miss can be a reconnect window rather than an app that never
 connected. If it stays unreachable on iOS, an error in the first bundle leaves
 the app without a packager connection at all, and no retry will make it a peer.
@@ -5416,8 +5533,9 @@ does not restart initialization. Confirm the bundle request and expected UI.
 
 Debug Android launches on an owned emulator that the run creates, or whose
 adoption from the pool it finishes, get up to 60 seconds for bundle loading;
-the verify phase names that budget. Existing emulators, remote targets, and physical devices keep the
-20-second budget.
+the verify phase names that budget. Existing emulators, remote targets, and physical devices get 20 seconds,
+extended up to 60 while an Expo dev client's manifest request is pending or was
+just served.
 Bundle delivery still requires the usual stability or app readiness check;
 an observed fatal error ends verification without waiting for the deadline.
 
@@ -5908,7 +6026,7 @@ is on PATH, the slot is default, no --runtime, --system-image or
 another platform or model, and a Debug run's Metro is reachable (not
 metro.tunnel off; on an Expo tunnel, run stim start --remote first). A recorded
 EAS session is not sticky: once this machine has room, auto runs here and the
-session bills until stim stop. If any check fails, or the
+session bills until stim stop or remote.easMaxDurationMinutes. If any check fails, or the
 setting is off, auto runs here and may wait in the existing FIFO device
 slot queue; --no-wait and --wait 0 refuse with STIM_AT_CAPACITY. The placement
 line explains the decision, the skipped hosts and why EAS was not used
@@ -5958,6 +6076,12 @@ Stim builds or fetches before reserving, records the session immediately, then
 uploads the app on every run. React Native and Expo Debug keep Metro here; the supervisor owns a
 private gateway bound to this machine's Tailscale address, pinned to the host peer
 and protected by a per-session secret. The host exposes only a loopback bridge.
+For an Expo dev client the bridge listens on this machine's Metro port, because
+the dev server writes that port into the manifest's bundle URL. When this run
+starts Metro, it asks the host and picks a port free on both Macs, moving the
+recorded port if the host uses it. A running Metro or a metro.port pin on a port
+the host uses refuses before the build: run stim stop, then stim ios --remote
+<machine> without stim start, or pin a port free on both Macs.
 No start --remote is needed; metro.tunnel and metro.publicUrl are ignored.
 Debug requires a running supervisor with private gateway support before reserving
 a simulator. --no-metro-check refuses with STIM_BAD_ARG for hosted Debug runs.
@@ -6237,12 +6361,18 @@ Metro verification enabled, not release builds or --no-metro-check.
    a missing ready message, and a startup error. Retain the relevant output.
 
 Without an observed pending, Stim keeps its default 3-second stability window
-after bundle delivery. Managed Metro servers report the native bundle response
+after bundle delivery. The window ends early, half a second after the app's
+React Native runtime logs \`Running "<name>"\` for this launch on either
+platform. A fatal record or an exited process before the window ends still
+fails the launch. An error after it, such as a first render that takes longer
+than that half second to throw, appears in \`stim logs --errors\`.
+Managed Metro servers report the native bundle response
 finishing; build-complete output alone does not close an observed request.
 Without response capture, Stim falls back to the build-complete marker.
 When Android reports queued JavaScript loading, Stim waits for a device
 JavaScript log before starting stability, bounded by the bundle timeout.
-Pending must be observed before the stability window closes. It opts into
+Pending must be observed before the stability window closes, early end
+included, so log it before the root component renders. It opts into
 waiting for ready until 30 seconds after the same completion signal.
 Repeated pending messages never extend the deadline. Ready can end the wait
 early; an app error or process exit interrupts it. No ready means readiness
@@ -6745,9 +6875,10 @@ AN ARTIFACT THE DEVICE ALREADY HOLDS IS NOT INSTALLED AGAIN
 A RUNNING APP IS RESTARTED, LIKE XCODE'S RUN
   Before it launches, \`ios\` and \`android\` read the device's process list.
   When the app is already running, from an earlier run or after an install
-  that was skipped, Stim stops it and launches it fresh: \`simctl terminate\`
-  on a simulator, \`am force-stop\` on an emulator or an \`android --device\`
-  phone. The new process requests its bundle, so launch verification has real
+  that was skipped, Stim stops it and launches it fresh: \`simctl launch
+  --terminate-running-process\` on a simulator (a separate \`simctl
+  terminate\` when the app opens through a URL), \`am force-stop\` on an
+  emulator or an \`android --device\` phone. The new process requests its bundle, so launch verification has real
   evidence instead of an old process that fetched nothing. In-app state from
   the previous session does not survive. The launch line says so:
 
@@ -7043,8 +7174,11 @@ WHAT MAKES THE CACHE ACTUALLY HIT: .FINGERPRINTIGNORE
   BUILD is what breaks that, and it fails silently -- a cache that never hits
   looks exactly like a cache that is not there.
 
-  Stim ignores two paths a fresh checkout never has and no native build reads:
-  android/local.properties and android/.idea. A project does not repeat those.
+  Stim ignores paths a fresh checkout never has and no native Debug build
+  reads: android/local.properties, android/.idea, *.xcodeproj/xcuserdata, and,
+  while a .gitignore pattern matches them (even when committed), the
+  \`react-native bundle\` output ios/main.jsbundle and ios/assets. A project
+  does not repeat those.
   Everything else is the project's call, including a lockfile whose checksums
   embed machine paths -- ignoring a path any project might read turns a slow
   build into a wrong one.
@@ -7479,11 +7613,18 @@ OPT-IN CONCURRENCY LIMITS (UNLIMITED BY DEFAULT)
   paths eligible under the source checkout's Git ignore rules, including .env
   and local configuration. The source's nonempty
   .worktreeexclude replaces its resolved worktree.exclude setting. Nested
-  registered worktrees, .DS_Store, .DerivedData, .idea, .jj, a project-local
-  .pnpm-store, and android/build/generated/autolinking caches are excluded,
-  including inside newly copied directories; pnpm refills its store from the
-  network or its global store. Gradle regenerates autolinking
-  for the destination checkout on its next build. Warm also skips paths
+  registered worktrees and ignored entries named .DS_Store, .DerivedData,
+  .idea, .jj or .pnpm-store are not copied, and neither is
+  android/build/generated/autolinking. Warm never walks a copied directory, so
+  a .DS_Store or .idea inside a copied directory stays. Warm deletes only
+  these paths from the copy: .pnpm-store in a copied node_modules (pnpm
+  refills it from the network or its global store), the autolinking directory
+  under a copied android, android/build or android/build/generated (Gradle
+  regenerates it for the destination checkout on its next build), and the
+  expo-modules-jsi/apple/.DerivedData Xcode build state, directly under
+  node_modules or in the pnpm virtual store. An ignored directory that Git
+  reports above those names (for example an app directory with no tracked
+  files) is copied as is. Warm also skips paths
   overlapping a nested destination worktree or below a symlink ancestor.
   Tracked .idea settings come from Git and stay untouched by warm.
 
@@ -7522,7 +7663,10 @@ OPT-IN CONCURRENCY LIMITS (UNLIMITED BY DEFAULT)
 
   Warm copies directly into the destination, without intermediate staging.
   Keep the source checkout and the linked worktree on the same volume to
-  retain copy-on-write cloning where supported. Cross-volume copies require
+  retain copy-on-write cloning where supported. On macOS with the Command Line
+  Tools, an ignored directory on the same APFS volume, such as node_modules or
+  ios/Pods, is cloned in one step, so a large one takes seconds; elsewhere
+  warm clones or copies file by file. Cross-volume copies require
   full file data; doctor reports that cost. STIM_TMPDIR and machine tempDir do
   not affect warming.
 
@@ -8005,6 +8149,24 @@ THE POOL: WHICH DEVICE AN ID-LESS \`--device\` PICKS
 
     { "ios": { "simslimProfile": ".simslim/dev.json" } }
 
+  To slim every Stim-owned iOS simulator on a Mac without a profile per app,
+  set it on the machine layer:
+
+    stim settings set ios.simslim on --scope machine
+
+  With \`ios.simslim\` on and no \`ios.simslimProfile\`, Stim runs
+  \`simslim on <udid>\` with SimSlim's default categories. A project profile
+  always applies in place of the defaults. A workspace, repo or committed
+  \`ios.simslim off\` opts that app out and restores stock services on its
+  simulator. The defaults disable push, StoreKit, iCloud, Safari sync, Mail,
+  Calendar and Contacts services, among others; move an app that needs them
+  to a profile that keeps those categories, or to \`off\`. A running or
+  parked simulator is slimmed the next time Stim boots or adopts it, and an
+  already slim simulator is left alone, so only the first slim reboots it.
+  Without the \`simslim\` command, doctor reports it and \`stim ios\` boots
+  the simulator unslimmed with a one-line note. Hosted simulators on a named
+  Mac are never slimmed, whatever either Mac's setting says.
+
   SimSlim 0.8 requires iOS 18.5 or newer. On each local \`stim ios\`,
   Stim reconciles that profile on the owned simulator before the app build.
   The first change can update services and reboot the simulator. A matching
@@ -8063,6 +8225,8 @@ HOST MEMORY PRESSURE AND STALLED SIMULATORS
     Watchman                       stim gc --delete --cache watchman
     Gradle or Kotlin daemon        stim gc --delete --cache gradle-daemons
   Any other process is named with its size only; ask before quitting it.
+  Boot does not wait for this read: the pressure message prints at once and the
+  named processes follow on a second memory line when top finishes.
   Doctor skips this check when STIM_HOME is set: processes are machine-global.
 
   If pressure is elevated, free host memory before retrying. Use \`stim stop\`
@@ -8173,8 +8337,8 @@ DISK PRESSURE LEVELS
        android/build, android/.gradle and .build, at a project root, the
        worktree root, or apps/* and packages/*
     4. owned simulators and emulators of workspaces idle for the short window
-    5. Stim temp directories and xctrace recordings in TMPDIR unmodified for
-       24 hours, with gc --delete's checks (see stim guide cleanup gc)
+    5. Stim temp directories, xctrace recordings and SwiftPM temp directories
+       in TMPDIR unmodified for 24 hours, with gc --delete's checks (see stim guide cleanup gc)
   Level 3:
     1. the Swift compilation cache, emptied whole under the same build rule;
        when a build keeps it, the last pass's blocked reasons name its size
@@ -8487,6 +8651,24 @@ LINKED WORKTREES
   has locked (unlock it first; --force does not override) and, without
   --force, uncommitted or unpushed work and initialized submodules. It then
   reclaims any owned resources it finds and removes the linked checkout.
+  Before git removes it, the command renames the worktree's ignored
+  directories (node_modules, ios/Pods, build outputs) into
+  $STIM_HOME/trash/<entry>, so git removes a light tree, and a detached,
+  low-priority rm deletes the entry after the command returns. Disk is freed
+  when that rm finishes. Through the programmatic API (createStim), the entry
+  is deleted before the call resolves. A directory that does not rename stays
+  for git to delete as before; on Windows, or when $STIM_HOME is on another
+  volume, nothing is renamed. When git refuses the removal, the directories
+  are moved back. Each entry holds an ownership claim while the command or its
+  rm uses it; gc reports every directory under trash with its size ("deleting"
+  while a removal holds it) and, for an entry Stim wrote, its source worktree.
+  gc --delete deletes only a remove-* entry with a valid trash.json whose
+  claim is free and whose worktree path is gone, which finishes a removal that
+  was interrupted, and keeps any other directory. An entry whose worktree path
+  still exists, as after a removal killed between the rename and git, stays
+  with the reason; if that worktree is the one the entry came from, run
+  \`stim worktree remove\` on it to finish the removal.
+  gc never moves the directories back.
   When git still refuses the removal, the kept ownership record no longer
   names the devices that were parked or deleted. A workspace that is in use
   (see IN USE below) keeps its directory, devices and registry entry, and the
@@ -8693,13 +8875,19 @@ TMPDIR LEFTOVERS
   under "TMPDIR leftovers", with their count, size and a remedy: Stim temp
   directories (stim-claim-*, stim-host-*, stim-fakehome-*,
   stim-hosted-macos-*, stim-server-*, stim-ws-*), xctrace recordings
-  (instruments*.ktrace) and Jest's jest_<uid in base 36> cache. \`gc --delete\` checks
-  them again and deletes a Stim temp directory or recording only when nothing
-  in it changed for 24 hours. It keeps a Stim temp directory that contains or
+  (instruments*.ktrace), SwiftPM temp directories (TemporaryDirectory.* with a
+  six-character suffix, left by swift and xcodebuild) and Jest's
+  jest_<uid in base 36> cache. \`gc --delete\` checks them again and deletes a
+  Stim temp directory, recording or SwiftPM temp directory only when nothing in
+  it changed for 24 hours. It keeps a Stim temp directory that contains or
   sits inside a registered project, holds a live or unverifiable ownership
   claim or a .lock directory that is not a claim set, or cannot be listed. It
-  keeps a recording that cannot be read, and every recording while an xctrace
-  or Instruments process runs or the process list cannot be read. Jest's cache and every other entry
+  keeps a recording or SwiftPM temp directory that cannot be read, every
+  recording while an xctrace or Instruments process runs, and every SwiftPM
+  temp directory while a swift or xcodebuild process runs, or when the process
+  list cannot be read. Stim's own SwiftPM macOS builds run swift with the
+  ambient TMPDIR, because SwiftPM keeps the locks for its shared caches there,
+  so their temp directories land here too. Jest's cache and every other entry
   are never deleted. gc never follows a symlink and never acts outside TMPDIR.
   With STIM_HOME set it neither reports nor deletes them, because TMPDIR is
   shared by every Stim home. Automatic maintenance runs the same deletion at disk pressure
@@ -8800,6 +8988,9 @@ DEVICE LEASES
   its holder and expiry, including holders no config knows. \`stop\` and
   \`worktree remove\` release the leases of the workspace they act on, and
   nothing else deletes a lease file: never remove another workspace's.
+  They also remove the \`adb reverse\` that an \`android --device\` run added
+  for this workspace's Metro port on that phone, using the serial and port the
+  run recorded in its workspace state; any other reverse on the phone stays.
 
 A device leaks when a project is abandoned WITHOUT either delete path -- the
 sim survives with nothing pointing at it. \`stim gc\` (no flag, writes
@@ -9289,6 +9480,13 @@ KEYS STIM READS
                         with STIM_BAD_ARG a path that escapes the app or
                         holds no .xcworkspace or .xcodeproj, and any value
                         on an Expo app, whose prebuild writes ios/.
+  ios.simslim           "on" or "off"; default "off", machine or project
+                        layers. "on" slims every Stim-owned iOS simulator
+                        with SimSlim's default categories when no
+                        ios.simslimProfile is set; a profile always wins. A
+                        workspace, repo or committed "off" opts that app out
+                        of a machine "on" and restores stock services. See
+                        \`stim guide lifecycle simslim\`.
   ios.simslimProfile    a SimSlim JSON profile under the app directory,
                         at most 64 KiB. Install the
                         external tool once with
@@ -9509,6 +9707,17 @@ ${ANDROID_AVD_CONFIG_HELP.map((line) => `                          ${line}`).joi
                         project scope; a committed value opts in everyone who
                         runs the app. Only the user enables it. See lifecycle
                         hosted-ios.
+  remote.easMaxDurationMinutes
+                        Minutes after which EAS stops each EAS Simulator session
+                        Stim creates (--remote eas or the easFallback), so a
+                        session nobody ended stops billing. A positive integer;
+                        default 30. Machine scope only. stop and gc --delete
+                        still end a session sooner; a run after the cap expires
+                        replaces the stopped session. Stim passes it to eas sim
+                        as --max-duration-minutes. EAS rejects a value above the
+                        account plan's session limit, so raise it only as far
+                        as the plan allows. A run reuses a live session without
+                        checking its remaining time.
   metro.tunnel          selects how a remote device reaches this workspace's
                         Metro after remote intent exists. Plain \`start\` stays
                         local. For Expo and bare React Native, "auto" (default)
@@ -9568,7 +9777,9 @@ ${ANDROID_AVD_CONFIG_HELP.map((line) => `                          ${line}`).joi
   metro.warmupUrl.android
                         an HTTP(S) URL or a /path ending in .bundle, with the
                         full query the app uses, including a matching platform.
-                        Unset uses Expo's manifest or bare React Native defaults.
+                        Unset uses the app's most recent bundle request from
+                        the workspace's metro log, then Expo's manifest or the
+                        bare React Native defaults.
                         Stim preserves the path and query but always requests
                         this workspace's verified local Metro port; a supplied
                         host and port are ignored. No defaults are added to an
@@ -10022,10 +10233,14 @@ Stim connects to a named machine only while its name still belongs to the pinned
 node and never sends the token to another node. \`doctor\` reports each
 remote machine's build pairing state and, for an approved one, asks it for one build
 offer and lists every reason it would not take this app's iOS build: no
-answer, another Stim build, CPU, Xcode, simulator SDK or CocoaPods, no
+answer, an incompatible Stim build, CPU, Xcode, simulator SDK or CocoaPods, no
 Bundler for an app whose Gemfile.lock pins CocoaPods, no iPhone simulator on
 the runtime \`stim ios\` builds for here, low disk, or busy. With Package.swift
 and no platform selection on a Mac, it also checks the macOS Xcode and SDK.
+Two machines build for each other when their Stim releases share a build
+compatibility version, which changes only when what a worker builds, how it
+builds, or the build messages change; their Stim builds can differ. A
+stim-server too old to report one needs the same Stim build as this machine.
 
 \`remote.build\` (machine scope, default auto) selects placement for
 \`ios\`, \`android\` and \`macos\`. \`--remote-build <auto|local|name>\`
@@ -10050,6 +10265,11 @@ and records buildMachine with builtOn absent. Build failures retain the selected
 value; builtOn is here or the configured machine entry when compilation ran.
 Prebuild and pod install still run on this machine before a named offload. A refusal
 starts no local xcodebuild, Gradle or SwiftPM compile.
+A React Native offload sends the tracked and untracked files, and the gitignored
+files the native fingerprint hashes or the Expo config reads, such as .env.local
+and other Expo .env files, secrets included. Nothing under node_modules and no
+build output the fingerprint ignores is sent. A fingerprint-mismatch refusal
+names the sources that differ and the files pod install or prebuild rewrote there.
 Run stim doctor --fix to ask for build access if not paired. A person on the
 worker approves it by running the stim-server setup command doctor printed, with
 its ticket and expiry. Check stim settings get remote.machines,
@@ -10081,10 +10301,20 @@ and install marker remain present.
 Older workers' dependency hints and mere checkout or build-folder presence do
 not influence this ranking. Exact completed-artifact hits still come first.
 
+The worker installs dependencies with the lockfile nearest the app: the first
+pnpm-lock.yaml, yarn.lock or package-lock.json in its directory or above it in
+the checkout, in the directory that holds it. An app with its own lockfile
+inside a larger repository installs its own dependencies there. In a pnpm
+workspace the worker installs every workspace package, as \`pnpm install\` does
+locally, because a native build can run a script of a package the app does not
+depend on.
+
 The worker runs the dependency install, prebuild, pods and xcodebuild with the
 Node the app pins, in its directory or the nearest one above it in the
-checkout, first on PATH, chosen as for Metro (see \`stim guide metro\`), and
-names that Node as NODE_BINARY in the iOS project's .xcode.env.local. A warm
+checkout, first on PATH, chosen as for Metro (see \`stim guide metro\`). On
+every offloaded iOS build, pinned or not, it writes the first node on its PATH
+(the pinned Node when it put one first) as NODE_BINARY in the iOS project's
+.xcode.env.local, replacing any export NODE_BINARY= line already there. A warm
 Gradle daemon keeps running React Native's node steps on the Node it started
 with. When no installed Node fits the pin, the steps run on the worker's node
 and a deps-failed or prebuild-failed reason names the pin and that Node's
@@ -10102,7 +10332,8 @@ STIM_REMOTE_BUILD_MODE overrides it for one command. Device, Release and
 and iOS/Android runs with the build cache off, always build here. Hosted iOS
 Debug builds can use a separate --remote-build, targeting the hosting Mac's
 architecture and runtime.
-macOS uses matching Xcode and macOS SDK, with a per-client SwiftPM dependency
+macOS uses matching Xcode and macOS SDK (not when --remote-build and --remote name the
+same Mac; see stim guide macos), with a per-client SwiftPM dependency
 cache on the worker. It skips JavaScript dependencies, prebuild and pods; see
 stim guide macos. Completed caching requires macos.artifactInputs and a locally
 verified compile; remote output is not published under an unverified client key.
@@ -10131,9 +10362,10 @@ lookup. Release and physical-device builds keep their existing paths.
 SwiftPM, compiler and dependency caches use their existing paths.
 For iOS the machine's Xcode and simulator SDK must match, and it needs an
 iPhone simulator on the target runtime. Its project-selected CocoaPods must match too, unless
-the app's Gemfile.lock pins CocoaPods: both machines then run that version through
+the app's Gemfile.lock, in ios/ or the project root, pins CocoaPods: both machines then run that version through
 bundler, so the machine needs only Bundler on its stim-server PATH and
-installs the pinned gems itself on the first build. The comparison selects
+installs the pinned gems itself on the first build. This Mac's side of the
+comparison runs \`pod --version\` in the directory pod install runs in. The comparison selects
 the app's .ruby-version when installed, otherwise rvm's or rbenv's default Ruby, and only when neither exists the GEM_HOME, GEM_PATH and Ruby-related PATH entries of the machine's login shell (read once with $SHELL -lic), unless the caller already sets GEM_HOME, with pod install's UTF-8 locale defaults. pod install, including the Bundler run, uses the same environment.
 For Android its CPU may differ, since the APK's ABIs come from the NDK, so an
 x86_64 Linux or Windows machine running stim-server can build for an Apple silicon Mac. Its JDK major
@@ -10886,7 +11118,8 @@ build pool. remote.buildPoolDisabled excludes members from automatic placement,
 including its local fallback. Explicit local or named placement bypasses membership.
 Configure remote.machines
 and approve build access as described in stim guide settings. The worker needs
-matching Stim, CPU architecture, Xcode and macOS SDK, plus network access to
+matching Stim, CPU architecture, Xcode and macOS SDK (except for an app built and run on
+the same Mac, below), plus network access to
 fetch package dependencies the first time. It keeps SwiftPM dependencies in a
 per-client cache and incremental outputs per repository. It runs fixed swift
 build commands without JavaScript installs, prebuild or pods. It receives only
@@ -10894,6 +11127,12 @@ the files git lists (tracked and untracked, not ignored). Resource and catalog
 sources must be among those files. The client sends resolved sources relative
 to the repository root; the worker resolves them inside its checkout.
 
+With --remote <machine> and --remote-build naming the same machine (the same
+paired node), the app is built and run there, so this Mac's Xcode, macOS SDK and
+CPU architecture do not have to match: the worker needs the same Stim build
+compatibility version and its own Xcode and macOS SDK. This Mac's cache is skipped and the worker's cache
+identity comes from the worker's toolchain. Any other combination keeps the match.
+
 The client validates the development plist and resource entries before asking a machine. It verifies
 the returned archive's sha256, bundle identifier, executable, declared resources
 and ad hoc signature