@@ -2,6 +2,46 @@
 
 ## Unreleased
 
+- Changed (sessions): the implicit session is now keyed by workspace **and platform**, so one checkout
+  can drive iOS and Android without inventing a `--session` name for every command (#2580). An
+  implicit session was addressed by `cwd:<workspace>:default`, one slot per checkout, and it stayed
+  bound to the first device it touched. A repo that tests both platforms — a visual-regression run
+  across `react-native-paper` components, for example — could not open the second one at all: after
+  `open --platform ios`, `open --platform android` from the same directory failed with `INVALID_ARGS`
+  ("already bound to apple device \"iPhone 17\""), and so did `boot --platform android`, which binds
+  nothing and only needed a device to start. The hint was correct (`--session android` works), but
+  following it means threading a hand-written name through every command of both legs, and a script
+  that drops one flag silently talks to the other platform's device. `--platform` now selects the
+  implicit session, so the platform a script already declares is the only handle it needs:
+  `cwd:<workspace>:ios` and `cwd:<workspace>:android` coexist, each with its own device, app, and
+  artifact directory. Three rules keep the behavior that was already earned.
+  1. A platform-naming request joins the workspace's session only when it genuinely agrees with it,
+     so a session opened without `--platform` — which keeps the platform-less `default` leaf — stays
+     reachable from commands that do name a platform and keeps writing to its own artifact directory
+     instead of growing a twin beside it. A request that agrees on platform but names a different
+     device or target still gets the existing `INVALID_ARGS` refusal; it does not silently fork a
+     second same-platform session that one `--platform` would then have to disambiguate.
+  2. A request naming no platform joins the workspace's only implicit session — what every
+     single-platform script does today, so those are unaffected — and refuses with `AMBIGUOUS_MATCH`
+     when the workspace holds several, naming every address and the `--platform`/`--session` flag
+     that selects it, instead of choosing a platform by open order. Same for a broad selector such as
+     `--platform apple` that matches both this workspace's iPhone and its Mac.
+  3. Inventory commands — `session list`, `devices`, `doctor`, `capabilities`, `apps`, which the
+     registry classifies as `sessionKind: 'inventory'` — never claim a session and keep resolving an
+     address through the ambiguity. Refusing those would refuse the command an agent runs to resolve
+     it. `events` and `close` are deliberately not in that set: each reads or tears down one session,
+     and a silently-empty `events` or a `close` that closed nothing would be worse than the refusal.
+  Two adjacent repairs were required. A settling interaction published the live session under
+  `SessionState.name`, which for an implicit session is only `default` and not the address it answers
+  to, so `agent-device session list` already reported a phantom second row beside the real session;
+  under platform keying that phantom would also have read as a second session the caller has to
+  disambiguate, so the publisher now stores under the key the store itself owns, and workspace-session
+  counting collapses one session reachable under two addresses regardless of writer. And
+  `--session-lock`'s platform reaches `flags` only
+  after routing has chosen the key, so routing now reads `meta.lockPlatform` too — otherwise a
+  lock-policy caller, the exact audience that avoids naming sessions, would land on the wrong leaf.
+  Explicit `--session <name>` is untouched and still addresses one session verbatim.
+
 - Fixed: an iOS capture that no backend could read now says which backend was asked and what was on
   screen, instead of failing on the internal `regular iOS snapshot presentation requires a valid
   viewport` invariant alone (#2560). The runner declares such a payload sparse — backend, reason code,
 
@@ -417,7 +417,7 @@ export const TARGET_FLAG_DEFINITIONS: readonly FlagDefinition[] = [
     names: ['--session'],
     type: 'string',
     usageLabel: '--session <name>',
-    usageDescription: 'Named session',
+    usageDescription: 'Named session (implicit default is scoped to this workspace + platform)',
     projectConfig: true,
     recorded: false,
   },
 
@@ -20,6 +20,7 @@ import {
   prepareLockedRequestScope,
 } from '../request-execution-scope.ts';
 import { resolveSessionRequestLogPath } from '../session-artifact-paths.ts';
+import { resolveSessionScope } from '../session-routing.ts';
 import type { DaemonRequest } from '../daemon-request.ts';
 import { mkdtempForTestSync } from '../../__tests__/test-utils/tmp-dir.ts';
 import { makeTestScreenRecordingResource } from '../../__tests__/test-utils/screen-recording-live-handle.ts';
@@ -935,3 +936,41 @@ function makeRequest(overrides: Partial<DaemonRequest> = {}): DaemonRequest {
     ...overrides,
   };
 }
+
+// The `attachesToSession` routing option is derived from the command's own registry classification,
+// so a swapped derivation has to be visible somewhere: an inventory command must keep resolving an
+// address across implicit session ambiguity, and a session command must refuse instead of picking
+// one workspace session by open order.
+async function createScopeAcrossTwoImplicitWorkspaceSessions(command: string) {
+  const root = mkdtempForTestSync('agent-device-request-scope-ambiguity-');
+  fs.mkdirSync(path.join(root, '.git'));
+  const scope = resolveSessionScope({ ...makeRequest({ command }), meta: { cwd: root } });
+  if (scope.kind !== 'cwd') throw new Error('expected a cwd session scope');
+  const sessionStore = makeSessionStore('agent-device-request-scope-ambiguity-');
+  sessionStore.set(
+    `cwd:${scope.id}:ios`,
+    makeIosSession('default', { sessionScope: { kind: 'cwd', id: scope.id } }),
+  );
+  sessionStore.set(
+    `cwd:${scope.id}:android`,
+    makeAndroidSession('default', { sessionScope: { kind: 'cwd', id: scope.id } }),
+  );
+  return await createRequestExecutionScope({
+    req: makeRequest({ command, meta: { cwd: root, requestId: `ambiguity-${command}` } }),
+    sessionStore,
+    leaseRegistry: new LeaseRegistry(),
+  });
+}
+
+test('createRequestExecutionScope lets session list route across implicit session ambiguity', async () => {
+  const scope = await createScopeAcrossTwoImplicitWorkspaceSessions('session_list');
+
+  expect(scope.sessionName).toMatch(/^cwd:[a-f0-9]{16}:default$/);
+  await scope[Symbol.asyncDispose]();
+});
+
+test('createRequestExecutionScope refuses a session command across implicit session ambiguity', async () => {
+  await expect(createScopeAcrossTwoImplicitWorkspaceSessions('press')).rejects.toMatchObject({
+    code: 'AMBIGUOUS_MATCH',
+  });
+});
@@ -179,7 +179,8 @@ test('session list includes a cwd-scoped session opened by replay', async () =>
     data: {
       sessions: [
         expect.objectContaining({
-          name: expect.stringMatching(/^cwd:[a-f0-9]+:default$/),
+          // A platform-selecting request addresses that platform's own implicit session (#2580).
+          name: expect.stringMatching(/^cwd:[a-f0-9]+:ios$/),
         }),
       ],
     },