Skip to content

iOS: a leased simulator reads and writes only its own folders, never its seed's #1561

Open
0 of 2 issues completed

Description

@V3RON

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"]
Loading

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 /tmp or /var, or has a long path, with deviceSet: "default", turns iOS off until SIMLOCK_HOME moves. 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 clone of 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/diagnostics aside (slow lane).
  • Each of those leased simulators' data/Library/Logs link names its own log folder (slow lane).
  • A worker with deviceSet: "default" and SIMLOCK_HOME under /tmp reports driver.root-rejected reason sources-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_STALE with 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 default the 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 simlock the copies stay at <root>/<udid> and only the sources move, to the same padded folder rule as default, because moving the copies would end running leases at the upgrade and need simctl at startup.
  • Decided in the session: the folder name is src followed by _ to the needed length, because src never equals ios, android or the old ios-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 /private or neither, because iOS writes a folder under /private in 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 indexed mark, 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_STALE from 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 /tmp to $HOME/.sls (at most 9 characters after the home fit), because its deviceSet: "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"]
Loading

Completion conditions:

Open work in the same area:

Written by an agent.

Activity

  1. added
    feature:specSpec in progress, business and technical together.
    on Nov 15, 2026
  2. V3RON commented on Nov 15, 2026

    @V3RON
    ContributorAuthor

    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.

  3. V3RON commented on Nov 15, 2026

    @V3RON
    ContributorAuthor

    Spec updated: tasks #1569 and #1570 written; Task cells and the Tasks section filled.

    Written by an agent.

  4. added
    feature:plannedSplit into tasks. Never picked up itself.
    and removed
    feature:specSpec in progress, business and technical together.
    on Nov 15, 2026
  5. V3RON commented on Nov 16, 2026

    @V3RON
    ContributorAuthor

    Delivery run

    Merged: none
    Parked: #1569 — needs-hardware: slow-ios-window needs 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 §2
    Waiting: none
    Decided: none
    Asleep: 44 min

    Written by an agent.

  6. V3RON commented on Nov 16, 2026

    @V3RON
    ContributorAuthor

    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.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    feature:plannedSplit into tasks. Never picked up itself.

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions