Repository navigation
Description
Request: #1548
Problem
In the reporter's words (#1548): "On iOS, every simulator Simlock leases is a simctl clone of the kind's seed, and every copy keeps writing into that seed after it boots. [...] The seed grows by one poster snapshot per lease, and every lease of the kind reads and writes some of the same state."
Expected, in their words: "A lease's simulator reads and writes only its own folders, and a seed (or a baseline's source) stays as it was made."
A booted simulator stores absolute paths to its own device folder and log folder, in links, plists, JSON, SQLite rows, indexes and caches. simctl clone copies those bytes, and before a copy's first boot Simlock changes only its LaunchServices database. Measured on 2026-11-15 (Xcode 27.2, iPhone 17, throwaway sets laid out as Simlock's): within minutes of booting, a copy of a seed wrote 5 files into the seed (iOS 27.0) and 2 (iOS 27.2); a copy of a baseline saved from a used copy wrote 204 files into that used copy's folder (home-screen snapshots, the Photos library).
Who it is for
Anyone who leases iOS simulators: each lease should start from the state its seed or baseline was made with and leave that state as it was. And the operator of a worker, whose seeds and baselines grow on every lease today.
Outcome
A leased iOS simulator reads and writes only its own device folder and its own log folder. A seed, a baseline and the copy a baseline was saved from never change after they are made, however many leases copy them. Nothing a lease holder types changes.
How it works for the user
flowchart TD
A["lease an iOS simulator"] --> B["Simlock copies the seed or the baseline"]
B --> C["before the first boot: every stored path that names<br/>another simulator's folder now names the copy's own"]
C --> D["the copy boots and writes only into its own folders"]
S["the worker starts"] --> P{"can the sources folder have<br/>the device folder's path length?"}
P -- yes --> A
P -- no --> R["iOS is off; doctor says why and how to fix it"]
Before, after three leases of iPhone 17 / iOS 27.0:
$ find ~/.simlock/devices/ios-sources/<seed udid> -newer <seed>/device.plist -type f | grep -v diagnostics | wc -l
15
After:
$ find ~/.simlock/devices/src___________________/<seed udid> -newer <seed>/device.plist -type f | grep -v diagnostics | wc -l
0
A worker whose home cannot hold a sources folder of the right length, before and after:
$ simlock doctor # before: iOS is on
$ simlock doctor # after
driver-unavailable ios sources-path-unfit: Refusing the ios device set: /private/tmp/h is under /private, where iOS stores each path in two spellings, but Xcode's set /Users/al/Library/Developer/CoreSimulator/Devices is not. Set SIMLOCK_HOME to a folder outside /tmp and /var.
A baseline saved before this change, after the upgrade:
$ simlock lease --platform ios --baseline login-ready
error BASELINE_STALE: baseline login-ready is stale: saved in /Users/al/.simlock/devices/ios-sources, which copies cannot be fixed from; save it again
Examples
The sources folder's path (B7). L is the length of the device set's real path.
| Device set (real path) | $SIMLOCK_HOME (real path) |
Today's sources folder | After |
|---|---|---|---|
simlock: /Users/al/.simlock/devices/ios (L 30) |
/Users/al/.simlock |
…/devices/ios/sources |
/Users/al/.simlock/devices/src |
default: /Users/al/Library/Developer/CoreSimulator/Devices (L 49) |
/Users/al/.simlock |
…/devices/ios-sources |
/Users/al/.simlock/devices/src + 19 _ |
default, L 49 |
/Volumes/Fast/simlock |
…/devices/ios-sources |
/Volumes/Fast/simlock/devices/src + 16 _ |
simlock: /private/tmp/h/devices/ios (L 26) |
/private/tmp/h |
…/devices/ios/sources |
/private/tmp/h/devices/src (both under /private) |
default, L 49 |
/private/tmp/h |
…/devices/ios-sources |
refused sources-path-unfit (only the sources folder is under /private) |
default, L 49 |
/Users/al/a-very-long-folder-name/simlock |
…/devices/ios-sources |
refused sources-path-unfit (needs a name of 0 characters or fewer) |
simlock, configured deviceRoot: /d (L 2) |
/Users/al/.simlock |
/d/sources |
refused sources-path-unfit |
What could go wrong
- The first iOS lease of each kind after the upgrade takes a full first boot (about 40 s) once, because every seed is made again.
- Every baseline saved before the upgrade must be saved again: requests naming one fail until then.
- A worker whose home sits under
/tmpor/var, or has a long path, withdeviceSet: "default", turns iOS off untilSIMLOCK_HOMEmoves. Most homes (~/.simlock) are fine. - A future iOS may store a path in a compressed or checksummed file the swap cannot patch; that copy would write into its source again. Likely rare; the slow lane catches it on a new runtime.
Words used
- seed: the simulator Simlock makes once per model and OS, boots once and shuts down, and copies for every plain lease, e.g. the
iPhone 17/ iOS 27.0 seed. - baseline: a named source an operator saved from a leased simulator, e.g.
login-ready. - source: a seed or a baseline's simulator; never leased, never booted again.
- copy: a simulator made by
simctl cloneof a source; one per lease. - sources folder: the CoreSimulator device set that holds the sources, e.g.
~/.simlock/devices/src. - device set: the CoreSimulator folder the copies live in: Simlock's own (
deviceSet: "simlock",~/.simlock/devices/ios) or Xcode's ("default",~/Library/Developer/CoreSimulator/Devices). - stored path: an absolute path a simulator wrote into its own files, e.g.
data/Library/Logs→~/Library/Logs/CoreSimulator/<udid>. - foreign folder: a device folder (
<device set or sources folder>/<udid>) or log folder (…/Logs/CoreSimulator/<udid>) whose UDID is not the copy's own. - same-length swap: replacing a foreign folder's path with the copy's own, byte for byte, which keeps every file's length, so it is safe in any file format.
- WAL: SQLite's write-ahead log (
<db>-wal); its frames carry checksums, so it is flushed into the database rather than patched.
Non-goals
- Android: each copy is its own AVD folder already (ADR 0061 §2).
- Physical devices.
- Moving the copies: under both settings they stay where they are today.
- Fixing the unified-log history (
data/var/db/diagnostics/*.tracev3): it names the source's folder as text in old log lines, nothing follows it as a path. - Migrating a baseline saved before the upgrade: it turns stale and is saved again.
Completion conditions
- After three leases of one kind and two leases of a baseline saved from a used lease, on Xcode 27, no file in the seed, the baseline's source, or the folder of the lease it was saved from is newer than when it was made,
data/var/db/diagnosticsaside (slow lane). - Each of those leased simulators'
data/Library/Logslink names its own log folder (slow lane). - A worker with
deviceSet: "default"andSIMLOCK_HOMEunder/tmpreportsdriver.root-rejectedreasonsources-path-unfit, and doctor names the fix. - After the upgrade, a seed made before it is made again on the next lease of its kind, and a baseline saved before it answers
BASELINE_STALEwith the "save it again" reason.
Open questions
Decisions
- ADR 0076 — An iOS clone names only its own folders before its first boot (PR docs(adr): 0076 an iOS clone names only its own folders before its first boot #1564): sources live at a path as long as the device set's; before its first boot every clone has each foreign folder in its files and links swapped for its own, byte for byte.
- ADR 0061 — Every virtual device is a copy of a source: §1's sources locations and §2's iOS Copy row are narrowed by 0076.
- ADR 0048 — Xcode's device set under
default: the copies stay there; only the sources folder moves. - Decided in the session: same-length swap over a format-aware rewrite, because the rewrite still leaked through SQLite rows and caches in the measurements, and the swap leaked nothing in four copies (maintainer, 2026-11-15).
- Decided in the session: under
defaultthe sources folder is padded inside$SIMLOCK_HOME, and iOS is refused when it cannot fit, rather than a folder beside Xcode's set (maintainer, 2026-11-15). - Decided in the session: a baseline saved before the change turns stale with a "save it again" reason, rather than a one-time migration (maintainer, 2026-11-15).
- Decided in the session: under
simlockthe copies stay at<root>/<udid>and only the sources move, to the same padded folder rule asdefault, because moving the copies would end running leases at the upgrade and needsimctlat startup. - Decided in the session: the folder name is
srcfollowed by_to the needed length, becausesrcnever equalsios,androidor the oldios-sources, so an old folder and the new one never collide. - Decided in the session: lengths are compared on real paths, and both folders must be under
/privateor neither, because iOS writes a folder under/privatein both spellings (/tmp/…and/private/tmp/…, measured in Safari's preferences and ManagedSettings records). - Decided in the session: WALs are flushed when a source is made, not when it is copied, because a source is shut down and Simlock's own then; a WAL that cannot be flushed is left unpatched and logged, never patched.
- Decided in the session: the files that hold a foreign folder are found once, when the source is made, and recorded; each copy patches only those, because scanning a 2.4 GB baseline per copy took 13–17 s.
- Decided in the session: a source records every folder it names, its own included, and carries an
indexedmark, so a source that names none is told apart from one made before the change. - Decided in the session: core checks baselines for staleness once at startup, so an old baseline answers
BASELINE_STALEfrom the first request, not a provision failure. - Decided in the session: the refusal names its one cause and that cause's fix, three texts (maintainer, 2026-11-15).
- Decided in the session: each copy logs how long its swap took (I6), and the slow lane holds a saved baseline's copy to under 1 s, so a fall back to a full scan is caught (maintainer, 2026-11-15).
- Decided in the session: a copy whose swap fails is deleted, as a copy whose LaunchServices drop fails is today.
- Decided in the session: the slow lane's temporary folder moves out of
/tmpto$HOME/.sls(at most 9 characters after the home fit), because itsdeviceSet: "default"flows (e2e/slow-agent-device.test.ts:849,e2e/slow-ios-window.test.ts:101) would otherwise be refused. - Decided in the session: old seeds are destroyed and made again through today's stale-seed path, with no reason shown, because nobody names a seed.
Behaviours
| Id | Behaviour (invoker, action, what it sees) | Seam | Cases | Task |
|---|---|---|---|---|
| B1 | A worker starts with iOS on: the sources folder is chosen by S1's rule, made an owned root, and every later seed and baseline is made there | IosSimctlDriver.create, then provision, with the fake filesystem and fake simctl |
simlock with the default root; simlock with a configured deviceRoot that fits; default under the user's home; default with $SIMLOCK_HOME on another volume that fits; both sets under /private |
#1569 |
| B2 | A worker starts where no sources folder can fit: iOS is refused with driver.root-rejected reason sources-path-unfit and I1's message; Android starts |
IosSimctlDriver.create (refusal), and the daemon start through driver-discovery for the event |
default with $SIMLOCK_HOME under /private/tmp (I1 a); default with a home too long, name length below 3 (I1 b); simlock with a configured deviceRoot too short (I1 c); simlock with only the root under /private (I1 c) |
#1569 |
| B3 | A provision after the upgrade finds a ready seed whose row names another set path: the seed is deleted in its own set and a new one is made in the sources folder | provision with a seeded ios_source_data row |
row in the old <root>/sources; row in the old ios-sources; row in today's folder (kept) |
#1569 |
| B4 | A request names a baseline saved before the upgrade: it fails BASELINE_STALE with the reason I3, from the first request after the worker starts, and the warm pool provisions no copy of it |
daemon start (core converge runs checkStale once, after listStartupSources) → lease.request, with the fake iOS driver |
baseline row in the old folder, first request after start (stale); a warm target naming it (no provision); listSources failing at startup (logged, the worker starts); baseline row in today's folder (not stale); destroySource of the old baseline deletes it in its own set |
#1569 |
| B5 | An operator switches deviceSet with sources left in either setting's old or new sources folder: iOS is refused device-set-changed, as today, naming the folder that holds them |
IosSimctlDriver.create |
simlock → default with a seed in <root>/sources; with a seed in the simlock sources folder; default → simlock with one in ios-sources; with one in the default sources folder; none left (starts) |
#1569 |
| B6 | A seed or a baseline is made: every WAL in it is flushed into its database, then every file and link that names any device folder or log folder (I2's pattern with every UDID, the source's own included) is recorded (S2), and the row is marked indexed (S4) as it turns ready |
provision (seed made), saveSource |
seed with two WALs; baseline saved from a used copy; a WAL that cannot be flushed (logged, left out of S2, source still made); a source that names no folder (no S2 rows, still indexed) | #1570 |
| B7 | A copy is made for a lease, from a seed or from a baseline: before its first boot each recorded link target and file has every foreign folder swapped for its own (I2), and its length is unchanged | provision, provision with source |
a link to the source's log folder; a binary file naming the source's folder; a JSON file with \/ separators; a file naming the folder a baseline was saved from; both spellings under /private; a path already naming the copy (unchanged); a file that changed length (refused); the swap logs I6 |
#1570 |
| B8 | A copy whose swap fails is deleted and the provision fails, as for a failed LaunchServices drop | provision |
a recorded file that is gone; a write that fails | #1570 |
| B9 | A seed made before #1570 lands (not indexed, S4) is made again on the next lease of its kind; a baseline not indexed is stale with I3's reason | provision, and listSources, with ready rows |
seed not indexed (made again); seed indexed with no S2 rows (kept); seed indexed with S2 rows (kept); baseline not indexed (stale) | #1570 |
| B10 | The slow lane runs its deviceSet: "default" flows: their homes fit S1, leftover sources are pruned from S1, and slow-baseline finds the sources set at S1 |
scripts/slow-e2e.sh, e2e/helpers/lane-home.ts, e2e/slow-baseline.test.ts (slow lane) |
a default-set flow under $HOME/.sls (starts); a baseline source left in S1 (pruned); slow-baseline finds S1 |
#1569 |
| B11 | A seed the lane keeps between flows keeps its S2 rows and S4 mark, so the next flow copies it instead of making it again | e2e/helpers/lane-home.ts (slow lane) |
a kept seed reused by the next flow (not made again) | #1570 |
Stored state
| Id | What and where | Created, changed, deleted by | Listed or swept by | A restart mid-step leaves | Schema step | Task | Used by |
|---|---|---|---|---|---|---|---|
| S1 | The sources folder: realpath($SIMLOCK_HOME)/devices/src followed by _ until its real path is exactly as long as the device set's real path; an owned root (.simlock-owned.json, platform: ios) under both settings. Refused (B2) when the name would be shorter than 3, or when only one of the two folders is under /private. A folder that does not exist yet (Xcode's Devices on a fresh Mac, the other setting's root for B5) is measured as the real path of its nearest existing parent joined with the rest. Replaces <root>/sources (simlock) and $SIMLOCK_HOME/devices/ios-sources (default) for every new source |
made by #ensureSourcesSet on the first make; emptied by destroySource, nuke and doctor --purge-orphans |
listSources (orphans: a UDID folder no row names), doctor, nuke, the switch check (B5) |
an empty folder or a making row, swept as today (#sweepLeftovers) |
none | #1569 | #1570 |
| S2 | ios_source_files: one row per file or link of a ready source that names a device folder or log folder (any UDID): source_id (the ios_source_data row), relative_path (under the source's UDID folder, /-separated, at most 4096 bytes), kind (link or file) |
written in the same transaction as markReady; deleted with the source's row (deleteRow) |
read by every copy of the source (B7) | a making source has no rows; the sweep deletes the row and its files rows together |
ios_source_data +1 |
#1570 | — |
| S4 | ios_source_data.indexed: 1 once B6 ran for the row, set in the markReady transaction; rows from before #1570 have 0 |
markReady (B6) |
#findOrMakeSeed (B9), sourceStaleReason (B9), e2e/helpers/lane-home.ts keeps it with the row |
— | ios_source_data +1 |
#1570 | — |
| S3 | An ios_source_data row whose set_path is not S1 (made before #1569): a seed is destroyed and made again (B3); a baseline is stale (B4) and is deleted in its own set_path |
— (existing rows) | listSources, core checkStale, #findOrMakeSeed |
— | none | #1569 | — |
Interfaces
| Id | What | Shape and bounds | Errors and limits | Where | Task | Used by |
|---|---|---|---|---|---|---|
| I1 | OwnedRootError reason sources-path-unfit: in RootRejectionReason, the driver.root-rejected reason, and doctor's driver-unavailable finding |
one message per cause, <D> the device set's real path and <n> its length, <H> the real path of $SIMLOCK_HOME, <k> the characters left for the name. (a) default, home under /private (checked first): Refusing the ios device set: <H> is under /private, where iOS stores each path in two spellings, but Xcode's set <D> is not. Set SIMLOCK_HOME to a folder outside /tmp and /var. (b) default, too long: Refusing the ios device set: the sources folder must have a path as long as <D> (<n> characters), but <H>/devices/ leaves <k> characters for its name, fewer than 3. Set SIMLOCK_HOME to a folder whose real path is at most <n - 12> characters. (c) simlock with a configured deviceRoot <R>: Refusing the ios device set: the sources folder must have a path as long as drivers.ios.deviceRoot <R> (<n> characters), but <cause>. Remove drivers.ios.deviceRoot, or set it to a path of at least <len(H) + 12> characters that is under /private only when SIMLOCK_HOME is., <cause> being <H>/devices/ leaves <k> characters for its name, fewer than 3 or only one of <R> and <H> is under /private |
none | src/core/device-root.ts, src/drivers/ios/, EVENTS.md, the website events and troubleshooting pages |
#1569 | — |
| I2 | The same-length swap, swapForeignFolders(bytes, { deviceSet, sourcesSet, logsRoot, ownUdid }) |
returns the bytes with every <deviceSet or sourcesSet>/<UDID> and <logsRoot>/<UDID> whose UDID is not ownUdid replaced, keeping the spelling matched, by the same spelling of <deviceSet>/<ownUdid> or <logsRoot>/<ownUdid>; a separator is / or \/ and is kept as found; each folder is matched in its real path and, under /private, also without /private; UDIDs upper-case. logsRoot is <home>/Library/Logs/CoreSimulator, a new driver option set in src/daemon/driver-discovery.ts beside coreSimulatorRoot. A companion namesAnyFolder(bytes, …) answers whether any UDID matches, for B6 |
a result of another length is a DriverCrashError naming the file |
a pure function in src/drivers/ios/ |
#1570 | — |
| I3 | The stale reason of a baseline in S3 | saved in <set_path>, which copies cannot be fixed from; save it again, after "is stale:" as today |
answers BASELINE_STALE through the existing path |
sourceStaleReason, src/drivers/ios/index.ts |
#1569 | — |
| I4 | Filesystem port: readlink(path): Promise<string>, replaceSymlink(path, target): Promise<void>, readBytes(path): Promise<Uint8Array>, overwriteSameLength(path, bytes): Promise<void> (keeps mode and modification time; refuses another length) |
paths absolute | each wait bounded as the port's others | src/ports/filesystem.ts, its Node adapter and fake |
#1570 | — |
| I6 | The swap's log line, one per copy at debug level (written only when log.level is debug; the default is info, src/core/config.ts:914) |
swapped <n> files and <m> links in <ms> ms for <udid> |
— | src/drivers/ios/ (the driver's logger) |
#1570 | — |
| I5 | Flushing a WAL: the SQLite port opens <db> read-write and runs PRAGMA wal_checkpoint(TRUNCATE); the iOS driver gets a SqliteOpener option, set in src/daemon/driver-discovery.ts |
one database at a time | a database that does not open or checkpoint is logged (could not flush <path>: <reason>) and its WAL left out of S2 |
src/ports/sqlite.ts (existing opener) |
#1570 | — |
Existing code
Commit 353dcc7.
Searches: sourcesSet in src/drivers/ios/index.ts (17 hits); ios-sources in src/ (4); "sources" in src/drivers/ios/ (3); simctl clone / "clone" (2); dropLaunchServicesDatabase (4); set_path / setPath (6); device-set-changed in src/ and docs (7); RootRejectionReason (1); sourceStaleReason (3); deviceSet: "default" in e2e/ (3); lane_tmp in scripts/slow-e2e.sh (9).
| Id | Code (path:line) | Today | With this feature | Handled by |
|---|---|---|---|---|
| X1 | src/drivers/ios/index.ts:374-377 |
the sources set is <root>/sources (simlock) or $SIMLOCK_HOME/devices/ios-sources (default) |
S1's rule | B1, S1 |
| X2 | src/drivers/ios/index.ts:400-428 (create) |
refuses an invalid set and the other setting's leftovers, then proves the root | also proves S1 can fit, else I1 | B2, B5 |
| X3 | src/drivers/ios/device-set-leftovers.ts:17-50 |
the switch check reads <root>/sources and ios-sources |
also reads both settings' S1 folders | B5 |
| X4 | src/drivers/ios/index.ts:1144-1157 (#ensureSourcesSet) |
simlock: mkdirp; default: ensureOwnedRoot |
ensureOwnedRoot under both |
S1 |
| X5 | src/drivers/ios/index.ts:918-972 (provision) |
clones --set <sources>, writes the mark, drops the LaunchServices database, copies the overrides |
also runs I2 on S2's paths before the first boot; deletes the copy on failure | B7, B8 |
| X6 | src/drivers/ios/index.ts:823-865 (saveSource) |
clones the leased device into the sources set, drops the LaunchServices database, marks it ready | also flushes its WALs and records S2 before markReady; the baseline itself is never booted, so it gets no swap |
B6, B7 |
| X7 | src/drivers/ios/index.ts:1011-1065 (#makeSeed) |
create, boot, shut down, mark ready | flushes WALs and records S2 before markReady |
B6 |
| X8 | src/drivers/ios/index.ts:1003-1009 (#findOrMakeSeed) and :2653-2657 (seedIsStale) |
a seed is stale only when its runtime build changed | also when its set_path is not S1, or it is not indexed (S4); it is deleted with --set <its set_path> |
B3, B9 |
| X9 | src/drivers/ios/index.ts:2659-2673 (sourceStaleReason) |
runtime gone or changed, device type gone | also I3 for a row not in S1 | B4 |
| X10 | src/drivers/ios/index.ts:866-881 (destroySource) and :1134-1142 (#deleteSeedSimulator) |
deletes in this.#sourcesSet |
deletes in the row's set_path |
B3, B4 |
| X11 | src/drivers/ios/source-data.ts:4-33 |
ios_source_data, version 2 |
version 3 adds ios_source_files |
S2 |
| X12 | src/core/device-root.ts:10-21 |
RootRejectionReason has no sources-path-unfit |
adds it | I1 |
| X13 | src/ports/filesystem.ts:64-123 |
no readlink, symlink write or byte read |
I4 | I4 |
| X14 | scripts/slow-e2e.sh:36, :253 and e2e/helpers/env.ts:416 |
lane homes under /tmp/simlock-slow (TMPDIR="$lane_tmp/", mkdtemp(tmpdir(), "simlock-e2e-")) |
lane_tmp defaults to $HOME/.sls: under default, S1 fits only when the home is at most the user's home + 28 characters, and /simlock-e2e-XXXXXX takes 19, so e2e/slow-agent-device.test.ts:849 and e2e/slow-ios-window.test.ts:101 fit |
B10 |
| X17 | src/core/create-core.ts:443-449 (converge) |
drops replaced baselines and lists sources; checkStale runs only on list, doctor and component.removed (src/core/baselines.ts:241, src/core/doctor.ts:320, src/core/create-core.ts:280-281), so a stored stale reason is read by lease-acquisition-coordinator.ts:637 |
converge also runs checkStale once, after listStartupSources and before warmPool.start; a failure is logged (could not check baselines at startup: <reason>) as listStartupSources's are (create-core.ts:496-507), and startup carries on |
B4 |
| X18 | e2e/helpers/lane-home.ts:24-29, :186-195 |
keeps seeds between flows by copying ios_source_data rows; prunes leftovers in <iosDeviceSet>/sources |
prunes in S1 (#1569); also copies S2 rows and S4 (#1570) | B10, B11 |
| X19 | e2e/slow-baseline.test.ts:82-85 |
expects the sources set at <deviceSet>/sources or ios-sources |
expects S1 | B10 |
| X20 | src/daemon/driver-discovery.ts:190-200 |
passes coreSimulatorRoot and database |
also logsRoot and a SqliteOpener |
I2, I5 |
| X15 | src/drivers/ios/AGENTS.md (Seeds) and ADR 0061 §1–2 |
sources in <root>/sources or ios-sources; clones drop only the LaunchServices database |
the manual says S1 and I2; ADR 0076 narrows 0061 | #1569, #1570 |
| X16 | website/src/content/docs/docs/reference/events.mdx:199, worker/troubleshooting.mdx:62, using-devices/build-and-run.mdx:73 |
list today's refusal reasons | sources-path-unfit and its fix |
I1 |
Tasks
flowchart LR
A["#1569 sources folder as long as the device set"] --> B["#1570 byte swap before each copy's first boot"]
- iOS sources live in a folder as long as the device set, and sources made before are remade or stale #1569 iOS sources live in a folder as long as the device set, and sources made before are remade or stale — after it, every new seed and baseline sits where a copy's paths can be patched byte for byte, and an unfit home is refused with its fix. Risk: iOS refused on a home that should fit, or an old baseline failing as
PROVISION_FAILED. - A leased iOS simulator's stored paths name only its own folders before its first boot #1570 A leased iOS simulator's stored paths name only its own folders before its first boot — after it, a lease's simulator writes only into its own folders, and seeds and baselines stop changing. Risk: a copy failing to provision, or app data lost from a baseline's copy.
Completion conditions:
- No file in the seed, the baseline's source or the saved-from lease is newer than its making: A leased iOS simulator's stored paths name only its own folders before its first boot #1570 (
e2e/slow-ios-source-isolation.test.ts). - Each leased simulator's
Logslink names its own log folder: A leased iOS simulator's stored paths name only its own folders before its first boot #1570 (the same test). defaultwithSIMLOCK_HOMEunder/tmpreportssources-path-unfitand doctor names the fix: iOS sources live in a folder as long as the device set, and sources made before are remade or stale #1569.- An old seed is made again and an old baseline answers
BASELINE_STALE: iOS sources live in a folder as long as the device set, and sources made before are remade or stale #1569 (set path), A leased iOS simulator's stored paths name only its own folders before its first boot #1570 (not indexed).
Open work in the same area:
- iOS: simctl clone and create are cut off at a fixed 30 s, and under deviceSet "default" each cut-off clone leaves a simulator nothing can delete #1546 (PR fix(ios): a simulator's clone or create waits ios.simulator.createTimeoutMs and a late copy is deleted #1563, merged 2026-11-15): bounded
simctl cloneandcreateinprovision,saveSourceand#makeSeed, the functions both tasks change; the line numbers cited here are from before it, so read the functions by name. - A lease's label is its device's window title: lease --label #1240 (PR feat(ios): lease --label names the leased simulator #1243,
lease --labelnames the leased simulator): touchesprovision's clone name, not the sources or the Copy step; no Depends on, a merge conflict at most. - PRs feat(backends): register local backend modules #1497 and feat(backends): persist device backend ownership #1499 (draft, backend registry): touch the iOS driver's construction; drafts with no issue, so no Depends on.
Written by an agent.
Activity
V3RON commentedon Nov 15, 2026
Design posted: business sections, Decisions, Behaviours B1–B9, Stored state S1–S3, Interfaces I1–I5 and Existing code X1–X16; ADR 0076 drafted on #1564.
Written by an agent.
V3RON commentedon Nov 15, 2026
Spec updated: tasks #1569 and #1570 written; Task cells and the Tasks section filled.
Written by an agent.
V3RON commentedon Nov 16, 2026
Delivery run
Merged: none
Parked: #1569 —
needs-hardware:slow-ios-windowneeds Xcode 27.2 and 27.1 is selected; agent-device and Android timeouts under load, #1570 — review R9 open at the round cap: files over 64 MiB are never swapped, against ADR 0076 §2Waiting: none
Decided: none
Asleep: 44 min
Written by an agent.
V3RON commentedon Nov 16, 2026
Handoff
Done: design experiments on throwaway device sets. "Copy then remove" (boot a throwaway, clone it unbooted as the seed, delete it and its log folder) kept seeds and baselines unchanged in every run, with no crashes. With a same-length UDID swap (iOS 27.1, iPhone Duo), nothing leaked and two leases stayed private.
Not done: experiment 4, no-scan (LaunchServices drop only) against the UDID swap on iOS 27.2 / iPhone 17. It stopped before any lease booted; the session budget ran out.
Findings: a second-model review: keep the WAL flush and per-source index, add UTF-16BE and raw UUIDs, and do not rely on reappearing folders to detect misses. The swap took 6.1 s over 2.4 GB.
Blocked on: finishing experiment 4, then a maintainer choice of no-scan or UDID swap and an ADR 0076 amendment before #1570 resumes.
Written by an agent.