@@ -0,0 +1,23 @@
+import { afterEach, test, vi } from 'vitest';
+import assert from 'node:assert/strict';
+import * as daemonResolution from '@agent-device/daemon-contracts/daemon-resolution';
+import { createAgentDeviceClient } from './agent-device-client.ts';
+import { createTransport } from './__tests__/client-transport-fixture.ts';
+
+afterEach(() => vi.restoreAllMocks());
+
+for (const command of ['open', 'close'] as const) {
+  test(`${command} succeeds when optional Metro hint scope resolution fails`, async () => {
+    const setup = createTransport(async () => ({ ok: true, data: {} }));
+    const client = createAgentDeviceClient(setup.config, { transport: setup.transport });
+    vi.spyOn(daemonResolution, 'resolveDaemonPaths').mockImplementation(() => {
+      throw new Error('home directory unavailable');
+    });
+    const result =
+      command === 'open'
+        ? await client.apps.open({ app: 'com.example.app', platform: 'ios' })
+        : await client.sessions.close();
+    assert.equal(result.session, setup.config.session);
+    assert.equal(setup.calls[0]?.command, command);
+  });
+}
@@ -221,7 +221,7 @@ export function createAgentDeviceClient(
           };
         } finally {
           // Close is teardown intent: drop the dev-server binding even if the daemon call fails.
-          clearMetroSessionHintsQuietly(metroSessionHintsScope(config, options));
+          clearMetroSessionHintsQuietly(mergeClientOptions(config, options));
         }
       },
       saveScript: async (
@@ -276,7 +276,7 @@ export function createAgentDeviceClient(
       open: async (options: AppOpenOptions) => {
         const session = resolveRequestSession(options);
         const data = await executeCommand<Record<string, unknown>>('open', options);
-        recordOpenedMetroSession(metroSessionHintsScope(config, options), {
+        recordOpenedMetroSession(mergeClientOptions(config, options), {
           explicitRuntime: options.runtime !== undefined,
           runtime: mergeClientOptions(config, options).runtime,
           sessionReused: data.sessionReused === true,
@@ -361,13 +361,13 @@ export function createAgentDeviceClient(
           runtimeFilePath: options.runtimeFilePath,
           logPath: options.logPath,
         });
-        recordPreparedMetroSession(metroSessionHintsScope(config), result);
+        recordPreparedMetroSession(config, result);
         return result;
       },
       reload: async (options = {}) =>
         await reloadMetro({
           ...options,
-          runtime: readMetroSessionRuntime(metroSessionHintsScope(config)) ?? config.runtime,
+          runtime: readMetroSessionRuntime(config) ?? config.runtime,
         }),
     },
     capture: {
@@ -577,15 +577,4 @@ function mergeClientOptions(
   return { ...config, ...options };
 }
 
-function metroSessionHintsScope(
-  config: AgentDeviceClientConfig,
-  options: InternalRequestOptions = {},
-): { stateDir: string; session: string } {
-  const merged = mergeClientOptions(config, options);
-  return {
-    stateDir: resolveDaemonPaths(merged.stateDir ?? process.env.AGENT_DEVICE_STATE_DIR).baseDir,
-    session: resolveSessionName(merged.session),
-  };
-}
-
 export type * from './client/client-types.ts';
@@ -1,6 +1,6 @@
 import { test } from 'vitest';
 import assert from 'node:assert/strict';
-import { componentName, splitDisplayName } from './react-component.ts';
+import { componentKind, componentName, splitDisplayName } from './react-component.ts';
 
 test('splitDisplayName separates DevTools wrapper names from the component', () => {
   assert.deepEqual(splitDisplayName('Memo(ForwardRef(Row))'), {
@@ -14,3 +14,9 @@ test('tree names preserve non-React wrappers', () => {
   assert.equal(componentName('Memo(Animated(Row))'), 'Animated(Row)');
   assert.equal(componentName('ForwardRef(Memo(Row))'), 'Row');
 });
+
+for (const type of ['toString', 'constructor', '__proto__']) {
+  test(`inherited key ${type} is not a component kind`, () => {
+    assert.equal(componentKind(JSON.parse(JSON.stringify(type))), 'unknown');
+  });
+}
@@ -10,7 +10,7 @@ export const COMPONENT_KINDS: Readonly<Record<number, ComponentKind>> = {
 };
 
 export function componentKind(type: number): ComponentKind {
-  return COMPONENT_KINDS[type] ?? 'unknown';
+  return Object.hasOwn(COMPONENT_KINDS, type) ? COMPONENT_KINDS[type]! : 'unknown';
 }
 
 const HOC_PATTERN = /^([A-Za-z0-9_$]+)\((.+)\)$/;
 
@@ -1,6 +1,5 @@
-import type { CliOutput } from '../../commands/command-contract.ts';
 import type { CliFlags } from '@agent-device/contracts/command';
-import { writeCliOutput } from '../commands/shared.ts';
+import { runReactDevtoolsCommand } from '../commands/react-devtools.ts';
 import { vi } from 'vitest';
 import vm from 'node:vm';
 import { mkdtempForTestSync } from '@agent-device/test-kit';
@@ -18,10 +17,10 @@ export const TARGET = {
 
 /**
  * Serves `targets` from `/json/list`, evaluates debugger calls in `app`'s realm, and captures what
- * `command` prints. Callers restore the stubbed globals and spies after each test.
+ * the CLI prints. Callers restore the stubbed globals and spies after each test.
  */
 export function commandHarness(
-  command: (args: string[], options: ReactDevtoolsCommandOptions) => Promise<CliOutput>,
+  prefix: string[] = [],
   app = new FakeAppRuntime(),
   targets: unknown[] = [TARGET],
 ) {
@@ -49,9 +48,8 @@ export function commandHarness(
   });
   const run = async (...args: string[]) => {
     output.length = 0;
-    const result = await command(args, options);
-    await writeCliOutput(options.flags ?? {}, result);
-    return { code: 0, text: output.join('') };
+    const code = await runReactDevtoolsCommand([...prefix, ...args], options);
+    return { code, text: output.join('') };
   };
   return { app, run, options, stateDir, requested };
 }
@@ -3,15 +3,14 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import type { CliFlags } from '@agent-device/contracts/command';
-import { runReactProfileCommand } from './react-profile-command.ts';
 import { commandHarness } from './react-devtools-command.fixtures.ts';
 
 afterEach(() => {
   vi.restoreAllMocks();
   vi.unstubAllGlobals();
 });
 
-const harness = () => commandHarness(runReactProfileCommand);
+const harness = () => commandHarness(['profile']);
 
 function bindSession(stateDir: string, controlBaseUrl: string) {
   fs.mkdirSync(path.join(stateDir, 'metro-sessions'), { recursive: true });
 
@@ -1,21 +1,13 @@
 import { afterEach, test, vi } from 'vitest';
 import assert from 'node:assert/strict';
-import { isInspectCommand, runReactInspectCommand } from './react-devtools-inspect-command.ts';
 import { commandHarness } from './react-devtools-command.fixtures.ts';
 import { FakeAppRuntime, MEMO_TYPE, encodeOperations } from './react-devtools-runtime.fixtures.ts';
-import type { ReactDevtoolsCommandOptions } from './react-devtools-connection.ts';
 
 afterEach(() => {
   vi.restoreAllMocks();
   vi.unstubAllGlobals();
 });
 
-async function inspectCommand(args: string[], options: ReactDevtoolsCommandOptions) {
-  const [command, ...rest] = args;
-  assert.ok(isInspectCommand(command));
-  return await runReactInspectCommand(command, rest, options);
-}
-
 /** An app whose list renders two memoized rows, one of which logged an error. */
 function listApp(): FakeAppRuntime {
   const app = new FakeAppRuntime();
@@ -43,7 +35,7 @@ function listApp(): FakeAppRuntime {
   return app;
 }
 
-const harness = (app = listApp()) => commandHarness(inspectCommand, app);
+const harness = (app = listApp()) => commandHarness([], app);
 
 test('tree prints the mounted components with refs', async () => {
   const { run } = harness();
 
@@ -268,6 +268,34 @@ test('prop sampling and inspection use the renderer that owns the element', () =
   assert.deepEqual(inspected.elements['3']?.props, { data: { label: 'owned' }, cleaned: [] });
 });
 
+for (const confirmedOwner of [false, true]) {
+  test(`${confirmedOwner ? 'confirmed' : 'unconfirmed'} renderer failure respects element ownership`, () => {
+    const app = new FakeAppRuntime();
+    app.install();
+    app.renderer.props.set(3, { data: { label: 'owned' }, cleaned: [] });
+    const foreign = Object.assign(Object.create(app.renderer), {
+      hasElementWithId: confirmedOwner ? () => true : undefined,
+      inspectElement: () => {
+        throw new Error('renderer unavailable');
+      },
+    });
+    app.hook.rendererInterfaces.clear();
+    app.hook.rendererInterfaces.set(1, foreign);
+    app.hook.rendererInterfaces.set(2, app.renderer);
+    assert.deepEqual(
+      app.call('describeProps', { '3': ['label'] }),
+      confirmedOwner ? {} : { '3': { label: 'string' } },
+    );
+    const inspected = app.call<{ elements: Record<string, { props?: unknown; error?: string }> }>(
+      'inspect',
+      [3],
+    );
+    if (confirmedOwner) assert.equal(inspected.elements['3']?.error, 'renderer unavailable');
+    else
+      assert.deepEqual(inspected.elements['3']?.props, { data: { label: 'owned' }, cleaned: [] });
+  });
+}
+
 test('a renderer whose profiling data cannot be read fails the stop instead of returning no commits', () => {
   const app = new FakeAppRuntime();
   app.install();
 
@@ -344,19 +344,21 @@ export const REACT_DEVTOOLS_RUNTIME_SOURCE = String.raw`
 
   function inspectBackendElement(id) {
     var found = null;
+    var failure = null;
     eachRenderer(function (ri) {
       if (found || (ri.hasElementWithId && !ri.hasElementWithId(id))) return;
       var result;
       try { result = ri.inspectElement(nextRequestID++, id, null, true); } catch (e) {
-        found = { error: String(e && e.message || e) };
-        return;
+        result = { type: 'error', message: String(e && e.message || e) };
       }
       if (!result || result.type === 'not-found') return;
-      found = result.type === 'full-data'
-        ? { value: result.value, name: lookupName(ri, id) }
-        : { error: result.message || result.type };
+      if (result.type === 'full-data') found = { value: result.value, name: lookupName(ri, id) };
+      else {
+        failure = { error: result.message || result.type };
+        if (ri.hasElementWithId) found = failure;
+      }
     });
-    return found || { missing: true };
+    return found || failure || { missing: true };
   }
 
   function inspectOne(id) {
 
@@ -3,13 +3,12 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import vm from 'node:vm';
-import { runReactProfileCommand } from './react-profile-command.ts';
 import { InspectorSession } from './metro-inspector.ts';
 import { commandHarness, TARGET } from './react-devtools-command.fixtures.ts';
 import { FakeAppRuntime, MEMO_TYPE, encodeOperations } from './react-devtools-runtime.fixtures.ts';
 
 const harness = (app?: FakeAppRuntime, targets?: unknown[]) =>
-  commandHarness(runReactProfileCommand, app, targets);
+  commandHarness(['profile'], app, targets);
 
 afterEach(() => {
   vi.restoreAllMocks();
@@ -261,13 +260,16 @@ test('drill-down views read the saved recording, not a trimmed analysis', async
   assert.equal(saved.version, 2);
   assert.equal(saved.profile.commits.length, 3);
   assert.match((await run('report', 'Row')).text, /changed props: onPress 36 \(function\)/);
+  assert.doesNotMatch((await run('report', 'Row')).text, /collection may have been interrupted/);
 });
 
 test('stop saves the raw recording before optional prop inspection', async () => {
   const { app, run, stateDir } = harness();
   await run('start');
   recordRowRenders(app);
-  let checkpoint: { profile: { commits: unknown[] }; propKinds: unknown } | undefined;
+  let checkpoint:
+    | { profile: { commits: unknown[] }; propKinds: unknown; notes: string[] }
+    | undefined;
   vi.mocked(InspectorSession.connect).mockResolvedValue({
     evaluate: async (expression: string) => {
       if (expression.includes('.describeProps(')) {
@@ -282,6 +284,9 @@ test('stop saves the raw recording before optional prop inspection', async () =>
   const stopped = await run('stop');
   assert.equal(checkpoint?.profile.commits.length, 3);
   assert.deepEqual(checkpoint?.propKinds, {});
+  assert.deepEqual(checkpoint?.notes, [
+    'Changed prop values have not been inspected; collection may have been interrupted.',
+  ]);
   assert.match(stopped.text, /Changed prop values could not be inspected: inspection unavailable/);
   assert.match((await run('report', 'Row')).text, /renders 36/);
 });
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ export const COMPONENT_KINDS: Readonly<Record<number, ComponentKind>> = {`
`10`	`10`	`};`
`11`	`11`
`12`	`12`	`export function componentKind(type: number): ComponentKind {`
`13`		`- return COMPONENT_KINDS[type] ?? 'unknown';`
	`13`	`+ return Object.hasOwn(COMPONENT_KINDS, type) ? COMPONENT_KINDS[type]! : 'unknown';`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`const HOC_PATTERN = /^([A-Za-z0-9_$]+)\((.+)\)$/;`