Repository navigation
Description
Request: #1557
Problem
In the reporter's words: "A memory-constrained worker serving coding agents needs to avoid full-mode iOS simulators, including when a client requests full mode." They ask: "Could an operator restrict which modes a worker serves and return a clear refusal when a requested mode is unavailable?"
Today every worker serves both modes. ios.defaultMode only picks the mode of a request that names none. A client can still ask --mode full. A slim request on iOS below 18.5 quietly becomes full. Warm-pool targets, learned kinds and full baselines boot full simulators with no request at all.
Who it is for
An operator who runs a shared worker, alone or behind a gateway, for coding agents. The machine is short of memory, and the agents ask for whatever mode they like.
Outcome
- The operator lists the iOS modes the worker serves with one setting:
simlock config set ios.modes '["slim"]', then a restart. - From then on that worker never plans or boots a full iOS simulator: not for a lease, a warm target, a learned kind or a baseline.
- A lease that would need a full simulator is refused at once, with
MODE_UNAVAILABLEand a message that names the setting and what to ask for instead. It never waits, and it downloads nothing unless the request itself allowed a download of an iOS version that then turns out too old to slim. - A request that names no mode gets a slim device, because the default follows the one served mode.
- Through a gateway, a full request goes to a worker that still serves full. When none does, it gets the same code from the gateway.
How it works for the user
flowchart TD
A[Operator: config set ios.modes '[slim]', restart] --> B[Worker serves slim only]
C[Agent: simlock lease --platform ios ...] --> G{Through a gateway?}
G -- yes --> H{A known worker serves the mode?}
H -- no --> X[MODE_UNAVAILABLE from the gateway]
H -- yes --> D
G -- no --> D[Worker resolves the mode: asked, baseline's, or default]
D --> E{Resolved mode served?}
E -- no --> Y[MODE_UNAVAILABLE at once]
E -- yes --> F[Granted or waits, as today]
Before:
$ simlock config set ios.modes '["slim"]'
{"error":{"code":"USAGE","message":"Invalid config after setting ios.modes: Unknown config key: \"ios.modes\""}}
$ simlock lease --platform ios --mode full
{"leaseId":"…","device":{"platform":"ios","model":"iPhone 17","mode":"full",…}}
After:
$ simlock config set ios.modes '["slim"]'
Updated ios.modes in /Users/alex/.simlock/config.json; takes effect on daemon restart.
$ simlock daemon stop && simlock daemon start
$ simlock lease --platform ios --mode full
{"error":{"code":"MODE_UNAVAILABLE","message":"This worker does not serve full iOS simulators (ios.modes is [\"slim\"]); ask for a slim one (--mode slim, or mode: \"slim\")"}}
$ echo $?
12
$ simlock lease --platform ios
{"leaseId":"…","device":{"platform":"ios","model":"iPhone 17","mode":"slim",…}}
$ simlock catalog --platform ios
iOS
Modes served: slim
…
Examples
On a worker with ios.modes: ["slim"], ios.defaultMode unset, iOS 26.1 and iOS 17.5 installed, a full baseline checkout and a slim baseline quick:
| Input | Today | After |
|---|---|---|
lease --platform ios |
full device | slim device |
lease --platform ios --mode slim |
slim device | slim device |
lease --platform ios --mode full |
full device | MODE_UNAVAILABLE (I2, asked) |
lease --platform ios --mode slim --os 17.5 |
full device (iOS 17.5 cannot be slimmed) | MODE_UNAVAILABLE (I2, cannot slim) |
lease --platform ios --os 17.5 |
full device | MODE_UNAVAILABLE (I2, cannot slim) |
lease --baseline checkout |
full copy | MODE_UNAVAILABLE (I2, baseline) |
lease --baseline quick |
slim copy | slim copy |
lease --platform ios --mode full --no-wait |
full device, or NO_CAPACITY |
MODE_UNAVAILABLE |
lease --platform ios --mode full --os 26.2 --allow-download (26.2 not installed) |
downloads, then full device | MODE_UNAVAILABLE; nothing downloads |
lease --platform ios --mode slim --os 17.4 --allow-download (17.4 not installed) |
downloads, then full device | downloads, then MODE_UNAVAILABLE (I2, cannot slim) |
lease --platform ios --physical |
iPhone | iPhone (modes are for simulators) |
lease --platform android |
emulator | emulator |
The config key (I1):
| Input | Today | After |
|---|---|---|
config set ios.modes '["slim"]' |
refused, exit 2: Unknown config key: "ios.modes" |
written |
config set ios.modes '["full"]' |
refused, unknown key | written; a slim request is then refused |
config set ios.modes '["slim","full"]' |
refused, unknown key | written; same as unset |
config set ios.modes '[]' |
refused, unknown key | refused, exit 2: expected a non-empty list of "slim" and "full", each once |
config set ios.modes '["slim","slim"]' |
refused, unknown key | refused, the same message |
config set ios.modes '["fast"]' |
refused, unknown key | refused, the same message |
config set ios.modes slim |
refused, unknown key | refused, the same message |
ios.modes: ["slim"] with ios.defaultMode: "full" set |
— | refused, exit 2: Invalid config value for "ios.defaultMode": expected a mode ios.modes lists |
ios.modes: ["slim"] with ios.defaultMode: "slim" |
— | accepted |
android.modes: ["full"] |
refused, unknown key | refused, unknown key (unchanged) |
What could go wrong
- An operator turns full off on a worker whose users need push, Siri or StoreKit. They see
MODE_UNAVAILABLEon their next full lease. Likely once; the message names the setting. - A slim boot whose services do not turn off still runs full. Rare; it is logged, and the device is granted as today.
- Behind an older gateway, a full request that one slim-only worker refuses is not tried on another worker.
Words used
- mode: whether an iOS simulator is
full(every system service runs) orslim(the heavy ones are off), e.g.--mode slim. - served mode: a mode listed in the worker's
ios.modes, e.g.["slim"]serves only slim. - resolved mode: the mode the worker would boot after its rules apply: the request's, or the baseline's, or the default, then full when iOS is below 18.5.
- warm pool: what keeps idle simulators booted ahead of leases, from configured targets and kinds it learned.
- learned kind: a device kind the warm pool keeps ready because leases asked for it.
- catalog: the list of models, runtimes and settings a worker reports, read by
simlock catalogand by a gateway to route. - known worker: one whose catalog the gateway holds and that is not on an incompatible protocol.
Non-goals
- Android: it has no slim, so it gets no key.
- Limiting memory by any other rule (per-lease RAM caps, counts per mode). The RAM budget and memory-pressure rules stay as they are.
- Deleting idle full simulators at start. Once no target or kind keeps them, the reaper's idle rules shut them down.
- Changing the mode at runtime without a restart.
- Refusing a slim boot whose services did not turn off.
Completion conditions
- With
ios.modes: ["slim"], every "After" row of the first Examples table answers as written, no simulator is created or booted for a refused one, and only the slim--allow-downloadrow downloads. - With it, a full warm target boots nothing, and
simlock doctorreports it with themode-unavailablereason. simlock catalogprints the served modes, andcatalog.getcarriesmodes: ["slim"].- Every config row of the second Examples table answers as written.
- Through a gateway with one slim-only worker and one worker serving both,
--mode fullis granted on the second; with only the slim-only worker it fails at once withMODE_UNAVAILABLE. - The configuration reference, the errors pages, the choosing-a-device page, the capacity page and the gateway routing page describe the setting.
Open questions
none
Decisions
- ADR 0082 — A worker may serve only some iOS device modes (PR docs(adr): propose 0082, a worker may serve only some iOS device modes (#1645) #1647): the key, the check on the resolved mode, the new code, the catalog field and the gateway rows.
- ADR 0007 — A lease request chooses the device mode: §3 "every worker honours both modes" and §4's fallback "never an error" are narrowed by 0082.
- ADR 0009 — Gateway routing: §4 gains a row and §5 one "cannot serve" code (0082 §4).
- ADR 0065 — A driver owns its config keys:
ios.modesis core's, besidedefaultMode, because leasing, the warm pool and the gateway act on it and the driver does not. - Decided in the session: the key is
ios.modes, a list, default both; no Android key (maintainer, 2026-11-17). - Decided in the session: the refusal is a new code,
MODE_UNAVAILABLE, exit 12, HTTP 422 (maintainer, 2026-11-17). - Decided in the session: a gateway routes by a
modesfield on each worker's iOS catalog entry and refuses at once when no known worker serves the mode (maintainer, 2026-11-17). - Decided in the session: with
ios.defaultModeunset and one mode listed, that mode is the default; a set default not listed fails the load, because a worker must serve the mode it gives a request that names none. - Decided in the session: the check is on the resolved mode, so a slim request on iOS below 18.5 is refused on a worker without full, because granting full there gives the operator the device they turned off.
- Decided in the session: the asked, default and baseline modes are checked before the spec is resolved, so they never download; only the cannot-slim case is checked after, so a slim request with
--allow-downloadof a missing iOS version below 18.5 downloads and is then refused, because only the driver knows a runtime cannot be slimmed and the case needs an explicit download of an old runtime. - Decided in the session: the warm pool is given the served modes, and its catalog check forgets a learned kind (plain or baseline) whose mode is not served, because learned kinds are planned from their stored spec and never pass the resolve step.
- Decided in the session: a slim boot whose services do not turn off is granted as today, because the check is a planning rule and the case is rare and logged.
- Decided in the session: the refusal's
lease.rejectedreason isunresolvable-spec, like every other resolve refusal, so no event shape changes. - Decided in the session: a warm target or learned kind the check refuses reports a new short reason
mode-unavailable, keeps no last spec (so its idle devices are not spared), and doctor reports it with its own text, becauseunresolvablewould keep full devices booted. - Decided in the session: the catalog field is sent only when the worker serves one mode, because absent already means both for every older worker.
- Decided in the session: the gateway's merged catalog lists the union of the workers' modes, and leaves
modesout when any worker serves both, sosimlock catalogthrough a gateway names a mode only when some worker serves it. - Decided in the session: a worker's relayed
MODE_UNAVAILABLEbefore a progress push counts as "cannot serve", with a new per-worker reasonmode-unavailable, so a gateway whose view is stale still tries the other workers. - Decided in the session: the refusal names both
--modeandmode:, so an MCP or HTTP caller can act on it, following A worker can serve enrolled phones only, and never boots a simulator or emulator #1588.
Behaviours
| Id | Behaviour (invoker, action, what it sees) | Seam | Cases | Task |
|---|---|---|---|---|
| B1 | An operator sets ios.modes (I1): config set accepts a non-empty list of slim and full, each once, and refuses anything else with I1's message; config get shows it, both when unset; the default mode follows a one-mode list when ios.defaultMode is unset, and a set default not listed fails the load |
loadConfig with the driver sections, and simlock config set / config get |
every row of the config Examples table; unset (both, default full); ["full"] with defaultMode unset (default full); a gateway's config holding it (ignored with the worker-key warning) |
#1651 |
| B2 | An agent sends an iOS lease whose resolved mode the worker does not serve: it is admitted as today (stored, lease.requested), then refused with I2, carrying I2's details, and lease.rejected reason unresolvable-spec: an asked, default or baseline mode before the spec is resolved (no download), the cannot-slim case after it; it never waits; a served mode is granted as today |
lease.request through the worker dispatcher, with the fake iOS driver |
every lease row of the first Examples table (no mode, slim, full, slim below 18.5, no mode below 18.5, full baseline, slim baseline, noWait, --physical, Android, --mode full --allow-download of a missing version: installComponent never called, slim --allow-download below 18.5: installed, then refused); ["full"] with --mode slim (refused); unset with --mode full (granted); the details { platform, mode, served } on the error |
#1651 |
| B3 | The warm pool runs on a worker that does not serve full: a full configured target, and a slim or mode-less target below iOS 18.5, report short mode-unavailable and boot nothing; a learned kind whose mode is not served, plain or baseline, is forgotten by the catalog check (I8) and boots nothing; a slim target fills |
core with leasing, the warm-pool converger, fake drivers | full target (short, nothing booted); mode-less target on iOS 17.5 (short); slim target on iOS 26.1 (filled); learned full kind from before the switch (forgotten); learned kind of a full baseline (forgotten); ["full"] with a learned slim kind (forgotten); a full idle device left from before (not in targeted(), so the reaper may shut it down) |
#1651 |
| B4 | An operator runs simlock doctor with a full warm target on a worker without full: the finding is I5 |
core Doctor over the warm pool's figures, with core and leasing and fake drivers, so the short reason comes from the real resolver |
full target with ["slim"] (I5); slim target with ["full"] (I5, slim wording); the same targets with the key unset (no finding) |
#1651 |
| B5 | A caller reads the catalog of a one-mode worker: the iOS entry carries modes (I3) and simlock catalog prints I4; a worker serving both sends no modes and prints Modes served: slim, full |
catalog.get through the dispatcher; simlock catalog |
["slim"]; ["full"]; unset; --json; Android entry (no field, no line) |
#1651 |
| B6 | An agent sends an iOS lease through a gateway: a request whose mode is named or comes from a baseline is routed only to a known worker that serves it (the can-serve stage passes the others over with reason mode-unavailable, I7); when none does, it fails at once with I6; a request with no mode goes to any worker |
gateway assess and select over worker views (src/gateway/routing), and lease.request through the gateway dispatcher with fake links |
--mode full with one slim-only worker (I6); slim-only plus both (routed to the second); slim-only plus a worker with no modes field (routed to the second); --mode slim with one full-only worker (I6, slim wording); no mode with only a slim-only worker (routed); full baseline on a slim-only worker (I6, baseline wording); slim-only worker first in id order plus a worker serving both (select picks the second, no dispatch to the first); explain gives mode-unavailable for the slim-only worker; --physical to a slim-only worker (routed) |
#1652 |
| B7 | A worker answers MODE_UNAVAILABLE to a gateway's dispatch before any progress push: the gateway leaves that worker out for that request, refreshes its catalog and walks again; with no other worker, the caller gets the worker's refusal |
lease.request through the gateway dispatcher with fake links |
a stale view of a slim-only worker plus a worker serving both (granted on the second); the stale slim-only worker alone (the worker's I2) | #1652 |
| B8 | A caller reads the catalog through a gateway: the merged iOS entry carries the union of the workers' modes, and none when any worker serves both |
aggregateCatalog (src/gateway/aggregate.ts), catalog.get through the gateway |
two slim-only workers (["slim"]); slim-only and full-only (["full","slim"], sorted); slim-only and one with no field (absent) |
#1652 |
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 | ios.modes in the user's config.json (I1) |
the operator, by simlock config set or by hand; read once at start |
config get; daemon.started's config snapshot |
— (read at start only) | none | #1651 | #1652 |
Interfaces
| Id | What | Shape and bounds | Errors and limits | Where | Task | Used by |
|---|---|---|---|---|---|---|
| I1 | Config key ios.modes |
list of "slim" and "full", 1 or 2 entries, no repeats, optional, default ["slim","full"]; a core key of Config["ios"] beside defaultMode and defaultModels; worker only. When unset in file and overrides, ios.defaultMode unset and one mode listed, the loaded defaultMode is that mode |
anything else fails the load: Invalid config value for "ios.modes": expected a non-empty list of "slim" and "full", each once (config set exit 2); a set defaultMode not listed: Invalid config value for "ios.defaultMode": expected a mode ios.modes lists; on a gateway, the worker-key warning of src/core/config-role-checks.ts:96 |
src/core/config-types.ts:166-168, config-defaults.ts:152, config-validators.ts:257, src/core/config.ts:202-215; src/contract/config-schemas.ts:152-154 (ios gains modes); website reference/configuration.mdx |
#1651 | #1652 |
| I2 | Worker refusal ModeUnavailableError and the error code MODE_UNAVAILABLE |
code MODE_UNAVAILABLE, kind domain, exit 12, HTTP 422; details { platform: "ios", mode: "slim" | "full", served: ("slim" | "full")[] }. Messages, by cause: asked or default — This worker does not serve <mode> iOS simulators (ios.modes is <list>); ask for a <other> one (--mode <other>, or mode: "<other>"); cannot slim — iOS <os> cannot be slimmed, and this worker does not serve full iOS simulators (ios.modes is ["slim"]); ask for iOS 18.5 or newer; baseline — Baseline "<name>" is <mode>, and this worker does not serve <mode> iOS simulators (ios.modes is <list>). <list> is the JSON list as configured |
thrown by AcquisitionSpecResolver: for an asked or default mode before #resolveOrInstall (after the mode line, :108), for a baseline right after baselineSpec, and for the cannot-slim case in checkedSpec; so warm-target resolve answers refusal mode-unavailable (I5); the resolver gets the served modes as a new option beside defaultModes, from deviceModeWiring; the code mapped in src/daemon/error-code.ts beside UnknownModelError, the details in leaseRequestRefusal; listed in the HTTP lease route's 422 codes; bumps the protocol by one |
src/leasing/acquisition-spec-resolver.ts, acquisition-errors.ts; src/daemon/worker-composition.ts:767-780, src/daemon/lease-request-refusal.ts:7-30; src/http/lease-declarations.ts:261; src/contract/errors.ts (ERROR_TABLE, ErrorDetailsMap); website reference/errors.mdx, using-devices/errors.mdx |
#1651 | #1652 |
| I3 | Catalog entry field modes on platformCatalogSchema |
z.array(deviceModeSchema).min(1).max(2).optional(); a worker sends it on its iOS entry only when it serves one mode; absent means both; bumps the protocol by one (with I2, one bump for the task) |
an older gateway strips it and keeps today's answers | src/contract/status-schemas.ts:307, src/contract/protocol.ts; set in StatusHandlers.#withDefaults (src/daemon/dispatcher-status.ts:22-29) |
#1651 | #1652 |
| I4 | simlock catalog line for iOS |
Modes served: <modes, comma-separated> after the runtimes line; slim, full when modes is absent |
— | src/cli/commands/catalog.ts:72 |
#1651 | — |
| I5 | Warm target short reason and doctor finding mode-unavailable |
TargetRefusal and warmPoolShortSchema gain mode-unavailable, treated like unknown-model (no last spec kept); doctor kind warm-pool-target-unreachable, reason mode-unavailable, message <target> cannot be met: this worker does not serve <mode> iOS simulators (ios.modes is <list>), remedy remove the target from warmPool.targets, or add <mode> to ios.modes; the contract's doctor reason enum gains it; DoctorConfig gains ios for the message's list |
— | src/core/domain.ts:83, src/core/warm-pool/policy.ts:54, src/leasing/acquisition-spec-resolver.ts:381 (refusalOf), src/contract/status-schemas.ts:73, src/contract/report-schemas.ts:101, src/core/doctor-findings.ts:157, src/core/doctor-types.ts:91, :142 |
#1651 | — |
| I8 | The served modes in the warm pool's catalog check | CoreConfig gains ios.modes, passed to the warm pool's CatalogCheck; gone also answers a kind whose spec.mode (a baseline kind's from its baseline's current spec) is iOS and not served; the forget log line says its mode is not served |
— | src/core/create-core.ts:48, src/core/warm-pool/catalog-check.ts:43-53, src/core/warm-pool/converger.ts:481-492 |
#1651 | — |
| I6 | Gateway refusal, a row of assessLeading after the NO_DRIVER row, for a request whose mode is named or comes from a baseline |
code MODE_UNAVAILABLE, reason unresolvable-spec, details { platform: "ios", mode, served: [] }; message No worker serves <mode> iOS simulators; ask for a <other> one (--mode <other>, or mode: "<other>"), or, when the mode is a baseline's, Baseline "<name>" is <mode>, and no worker that holds it serves <mode> iOS simulators |
applies when every known worker with iOS (for a baseline, every fitting holder) has modes without the request's mode; one helper servesMode(worker, request) in request-match.ts, asked by this row and by can-serve, so the two agree |
src/gateway/routing/serviceability.ts:25-34 (RejectionCode), :198-250; request-match.ts:54-65 (withBaseline) |
#1652 | — |
| I7 | Per-worker reason mode-unavailable: the can-serve stage returns it for a worker servesMode refuses (after the platform check, before the model check), and a relayed MODE_UNAVAILABLE is "cannot serve" |
CANNOT_SERVE_CODES and CANNOT_SERVE_REASONS gain it; WorkerReasonCode and gatewayWaitingReasonSchema gain mode-unavailable, shown as Mode not served by simlock list and the console; bumps the protocol by one |
— | src/gateway/routing/stages/can-serve.ts:4-16, src/gateway/fleet-dispatch.ts:57-65, :201-216, fleet-refusals.ts:17-25, routing/pipeline.ts:25-43, src/contract/lease-schemas.ts:112-131, src/cli/commands/list.ts:62-84, ui/src/model/waiting.ts:82-104; website gateway/fleet-console.mdx |
#1652 | — |
Existing code
Commit 1cd9315.
Searches: rg '"full"|defaultMode|deviceModeSchema' src (≈60 hits, read the non-test ones), rg 'CANNOT_SERVE|RejectionCode|refusalOf|unreachableTarget' src (≈12), rg 'stringArray|validateLeaseTtls' src/core (4).
| Id | Code (path:line) | Today | With this feature | Handled by |
|---|---|---|---|---|
| X1 | src/leasing/acquisition-spec-resolver.ts:108 |
the one place a request with no mode gets the worker's default | the default is the loaded defaultMode, which I1 keeps served |
B1, B2 |
| X2 | src/leasing/acquisition-spec-resolver.ts:125, :368-377 (checkedSpec) |
a non-slim mode or a driver's full answer becomes a full spec | a full spec on a worker without full, or a slim one on a worker without slim, throws I2 | B2 |
| X3 | src/drivers/ios/catalog.ts:95 |
a slim request the driver cannot slim gets a full spec, no error | unchanged; X2 turns it into I2 (cannot-slim message) | B2 |
| X4 | src/leasing/acquisition-spec-resolver.ts:133-167 (#resolveBaseline) |
a baseline's spec takes its own mode | its mode is checked against the served modes after baselineSpec |
B2 |
| X5 | src/leasing/acquisition-spec-resolver.ts:345, :381 (refusalOf) |
a thrown error becomes unknown-model, runtime-missing or unresolvable; unresolvable keeps the last spec |
I2 maps to mode-unavailable |
B3, I5 |
| X6 | src/core/warm-pool/converger.ts:626 |
a target with no mode takes the worker default | unchanged; the default is served by I1 | B3 |
| X7 | src/core/doctor-findings.ts:157-221 |
findings for runtime-missing and unknown-model only |
a mode-unavailable branch (I5) |
B4 |
| X8 | src/daemon/dispatcher-status.ts:22-29 |
adds defaultMode to the iOS entry |
adds modes too when one mode is served |
B5, I3 |
| X9 | src/daemon/error-code.ts:129-144 |
maps resolver errors to codes | maps ModeUnavailableError to MODE_UNAVAILABLE |
B2 |
| X10 | src/core/config.ts:202-215 |
cross-key checks run after the merge; worker-only checks in the else branch |
the defaultMode/modes check and the default rule run in the worker branch; config set runs them too (src/cli/commands/config.ts:56-60) |
B1 |
| X11 | src/gateway/routing/serviceability.ts:115-122, :172-180 |
assessFleet: leading rows, except, serving, capabilities; whyNotSlim already reads a worker's default mode |
a mode row and a per-worker mode filter (I6) | B6 |
| X12 | src/gateway/routing/stages/keeps-except.ts:4-16, stages/warm-hit.ts:20 |
an except request's mode is the baseline's or the worker's default; a mode-less warm hit uses servesDefaultMode |
unchanged: a mode-less request still goes to any worker | B6 |
| X13 | src/gateway/fleet-dispatch.ts:450-474 |
a relayed code outside CANNOT_SERVE_CODES is the request's final answer |
MODE_UNAVAILABLE joins the set (I7) |
B7 |
| X14 | src/gateway/aggregate.ts:250-281 |
unions slimCategories; does not merge defaultMode |
unions modes as B8 says |
B8 |
| X16 | src/core/warm-pool/catalog-check.ts:43-53, converger.ts:481-492 |
forgets a learned kind whose model, runtime, driver or baseline is gone; learned kinds are planned from their stored spec, never resolved | also forgets one whose mode is not served (I8) | B3 |
| X17 | src/gateway/routing/stages/can-serve.ts:4-16, src/gateway/fleet-dispatch.ts:201-216 |
select gets its views from fleet-dispatch, and can-serve filters on platform, model and runtime |
can-serve also filters on servesMode (I7) |
B6 |
| X18 | src/daemon/lease-request-refusal.ts:7-30, src/http/lease-declarations.ts:261 |
worker-side refusal details are built here; the HTTP route lists its 422 codes | I2's details and code added | B2 |
| X15 | website/src/content/docs/docs/worker/capacity.mdx:127, using-devices/choosing-a-device.mdx:111-137, reference/configuration.mdx:205, gateway/routing.mdx |
"A full request always gets a full device"; "the worker makes both kinds either way" |
each says a worker may serve one mode and refuse the other | #1651 (worker pages), #1652 (routing page) |
Tasks
flowchart LR
A[#1647 ADR 0082] --> T1[#1651 worker]
P1[#1598] --> T1
T1 --> T2[#1652 gateway]
P2[#1599] --> T2
- A worker refuses the iOS modes it does not serve (ios.modes, MODE_UNAVAILABLE) #1651 A worker refuses the iOS modes it does not serve (ios.modes, MODE_UNAVAILABLE) — an operator sets
ios.modesand the worker refuses every iOS lease, warm target and learned kind of a mode it does not serve, and shows the served modes in its catalog.
Risk: a slim-only worker still boots a full simulator, or refuses a served mode. - Through a gateway, an iOS lease goes only to a worker that serves its mode #1652 Through a gateway, an iOS lease goes only to a worker that serves its mode — a full lease through a gateway reaches a worker that serves full, or fails at once when none does.
Risk: a full lease is refused while another worker serves full, or reaches a slim-only worker.
Completion conditions: the lease and config Examples rows, the warm-target and doctor line, and the catalog line — #1651; the gateway line — #1652; the website pages — both (worker pages #1651, routing page #1652).
Open work in the same area:
- A worker serves only enrolled devices on a platform whose virtualDevices is false #1598 (A worker can serve enrolled phones only, and never boots a simulator or emulator #1588, PR feat(leasing): a worker serves only enrolled devices on a platform whose virtualDevices is false #1623 open): changes the same resolver step, the
iosconfig section, the catalog entry schema,catalog.get's defaults, the warm-pool target refusals and doctor's target findings. A worker refuses the iOS modes it does not serve (ios.modes, MODE_UNAVAILABLE) #1651 depends on it. - A worker and a gateway serve the daemon protocol on /v1/session with the token's identity #1639, connectSimlock and connectSimlockAdmin reach a remote farm with a URL and a token #1640, A held remote simlock lease and simlock mcp reconnect and keep their lease through a network drop #1642 (The CLI, simlock/client and simlock mcp reach a remote farm with a URL and a token #1635, remote farm, ready): each bumps the protocol, and connectSimlock and connectSimlockAdmin reach a remote farm with a URL and a token #1640 adds rows to
ERROR_TABLEand the exit-12 line ofreference/errors.mdxthat A worker refuses the iOS modes it does not serve (ios.modes, MODE_UNAVAILABLE) #1651 also changes. A worker refuses the iOS modes it does not serve (ios.modes, MODE_UNAVAILABLE) #1651 depends on A held remote simlock lease and simlock mcp reconnect and keep their lease through a network drop #1642, the end of that chain. - Through a gateway, a plain lease that only phones-only workers could serve gets the phones-only refusal #1599 (A worker can serve enrolled phones only, and never boots a simulator or emulator #1588): adds a row to
assessLeadingand a field to the merged catalog in the same files. Through a gateway, an iOS lease goes only to a worker that serves its mode #1652 depends on it. - Runtime warm-pool targets: warm.set and warm.list, kept in state.db #1143 (task:draft, runtime warm targets): would add a second source of warm targets with a mode; no Depends on, since it is not ready and its targets resolve through the same step.
Written by an agent.
Activity
V3RON commentedon Nov 17, 2026
Design posted: business sections, Examples, Decisions (ADR 0082, PR #1647), Behaviours B1–B8, Stored state S1, Interfaces I1–I7, Existing code X1–X15.
Written by an agent.
docs(adr): accept 0082 (#1645)
V3RON commentedon Nov 17, 2026
Spec updated: tasks #1651 (worker) and #1652 (gateway) written and linked; Task cells and the Tasks section filled; ADR 0082 accepted on PR #1647.
Written by an agent.