mobile-debug-mcp 0.36.0 → 0.37.0

package/test/device/automated/latency/snapshot-pair.ts

@@ -0,0 +1,143 @@
+import { writeFileSync } from 'node:fs'
+import { dirname, isAbsolute } from 'node:path'
+import assert from 'node:assert/strict'
+import { computeScreenFingerprint } from '../../../../src/utils/ui/index.js'
+import type { CaptureDebugSnapshotRawResponse, GetCurrentScreenResponse } from '../../../../src/types.js'
+import { buildFixture } from '../../../fixtures/latency-journey-app/build.js'
+import { BenchmarkSession, UnsafeMeasurement } from './end-to-end-session.js'
+import { cleanupFixture, command, environment, fixturePresent, treeHash } from './end-to-end-environment.js'
+import { summarizeAttempts, type Attempt } from './end-to-end-report.js'
+
+const device = process.env.LATENCY_DEVICE_ID ?? ''
+const baseline = process.env.SNAPSHOT_BASELINE_SERVER ?? ''
+const baselineSource = process.env.SNAPSHOT_BASELINE_SOURCE_SHA ?? ''
+assert.match(device, /^emulator-\d+$/)
+assert.ok(isAbsolute(baseline) && /^[a-f0-9]{64}$/.test(baselineSource), 'Provide the frozen baseline server path and source hash')
+const adb = (...args: string[]) => command('adb', ['-s', device, ...args])
+const app = 'dev.mobiledebugmcp.latencyfixture'
+const fixtureActivity = `${app}.MainActivity`
+const options = { includeScreenshot: false, includeLogs: false }
+const attempts: Attempt[] = []
+const sessions = {
+  baseline: new BenchmarkSession(device, true, baseline),
+  candidate: new BenchmarkSession(device, true)
+}
+type Build = keyof typeof sessions
+let installAttempted = false, launched = false, interrupted = false
+let fatal: string | undefined, metadata: ReturnType<typeof environment> | undefined
+let fixtureSha: string | undefined
+let nativeFreshness = false
+const baselineHash = treeHash(dirname(baseline))
+const cleanup = { servers: false, fixture: false }
+
+async function checkFixtureActivity(session: BenchmarkSession) {
+  const screen = await session.call('get_current_screen', {}, [])
+  assert.equal(screen.package, app)
+  assert.equal(screen.activity, fixtureActivity)
+}
+
+function verifyFingerprint(raw: CaptureDebugSnapshotRawResponse) {
+  const tree = raw.ui_tree
+  assert.ok(tree && tree.device.id === device && tree.snapshot_revision)
+  assert.equal(raw.snapshot_revision, tree.snapshot_revision)
+  assert.equal(raw.captured_at_ms, tree.captured_at_ms)
+  assert.match(raw.fingerprint ?? '', /^[a-f0-9]{64}$/)
+  const current: GetCurrentScreenResponse = { device: tree.device, activity: fixtureActivity, package: app, shortActivity: '' }
+  assert.equal(raw.fingerprint, computeScreenFingerprint(tree, current, 'android').fingerprint)
+}
+
+async function sample(build: Build, iteration: number) {
+  if (interrupted) throw new UnsafeMeasurement('INTERRUPTED')
+  const attempt: Attempt = { case: build, iteration, warmup: iteration < 3, success: false, setup_ms: 0, requests: [] }
+  attempts.push(attempt)
+  try {
+    await checkFixtureActivity(sessions[build])
+    const data = await sessions[build].call('capture_debug_snapshot', options, attempt.requests)
+    const raw = data.raw as CaptureDebugSnapshotRawResponse
+    assert.ok(raw.ui_tree?.elements.some(element => element.contentDescription === 'home-screen' || element.text === 'home-screen'))
+    await checkFixtureActivity(sessions[build])
+    if (build === 'candidate') {
+      verifyFingerprint(raw)
+      assert.equal(attempt.requests[0].tree.filter(event => event.type === 'acquisition_completed').length, 1)
+    }
+    attempt.success = true
+  } catch (error) {
+    attempt.failure = attempt.requests[0]?.failure ?? 'SNAPSHOT_ASSERTION_FAILED'
+    if (error instanceof UnsafeMeasurement) throw error
+  }
+}
+
+async function checkFreshness() {
+  const candidate = sessions.candidate
+  const before = (await candidate.call('capture_debug_snapshot', options, [])).raw as CaptureDebugSnapshotRawResponse
+  await candidate.call('run_journey', { steps: [
+    { id: 'open', type: 'tap', selector: { accessibility_id: 'saved-session' } },
+    { id: 'check', type: 'assert', assertion: { kind: 'element_visible', selector: { accessibility_id: 'idle-detail' } }, timeoutMs: 15000 }
+  ], defaults: { verificationMode: 'light' }, responseMode: 'compact' }, [])
+  await checkFixtureActivity(candidate)
+  const after = (await candidate.call('capture_debug_snapshot', options, [])).raw as CaptureDebugSnapshotRawResponse
+  await checkFixtureActivity(candidate)
+  verifyFingerprint(after)
+  assert.ok(after.ui_tree?.elements.some(element => element.contentDescription === 'idle-detail'))
+  assert.ok(after.snapshot_revision > before.snapshot_revision)
+  assert.notEqual(after.fingerprint, before.fingerprint)
+  nativeFreshness = true
+}
+
+async function main() {
+  const stop = () => { interrupted = true; for (const session of Object.values(sessions)) session.abort() }
+  process.on('SIGINT', stop); process.on('SIGTERM', stop)
+  try {
+    assert.equal(adb('get-state'), 'device')
+    assert.equal(adb('shell', 'getprop', 'ro.kernel.qemu'), '1')
+    const apk = buildFixture()
+    if (!fixturePresent(adb, app)) {
+      installAttempted = true
+      adb('install', apk)
+    }
+    const packagePath = adb('shell', 'pm', 'path', app).match(/^package:(.+)$/)?.[1]
+    assert.ok(packagePath)
+    fixtureSha = adb('shell', 'sha256sum', packagePath).split(/\s+/)[0]
+    assert.match(fixtureSha, /^[a-f0-9]{64}$/)
+    metadata = { ...environment(device, apk), fixture_sha256: fixtureSha }
+    adb('shell', 'am', 'force-stop', app)
+    launched = true
+    adb('shell', 'am', 'start', '-W', '-n', `${app}/.MainActivity`)
+    for (const session of Object.values(sessions)) await session.connect()
+    await sessions.baseline.call('expect_element_visible', { selector: { accessibility_id: 'home-screen' }, timeout_ms: 30000 }, [])
+    for (let iteration = 0; iteration < 13; iteration++) {
+      const order: Build[] = iteration % 2 ? ['candidate', 'baseline'] : ['baseline', 'candidate']
+      for (const build of order) {
+        console.log(`Round ${iteration + 1}/13 ${build}`)
+        await sample(build, iteration)
+      }
+    }
+    await checkFreshness()
+  } catch (error) { fatal = error instanceof UnsafeMeasurement ? error.message : 'SETUP_OR_FRESHNESS_FAILED' }
+  finally {
+    cleanup.servers = true
+    for (const session of Object.values(sessions)) {
+      try { await session.close(); cleanup.servers &&= session.transport.cleanupVerified }
+      catch { cleanup.servers = false }
+    }
+    try {
+      if (launched || installAttempted) cleanupFixture(adb, app, installAttempted)
+      cleanup.fixture = true
+    } catch { cleanup.fixture = false }
+    process.off('SIGINT', stop); process.off('SIGTERM', stop)
+  }
+  const summaries = summarizeAttempts(attempts)
+  const prior = summaries.baseline
+  const next = summaries.candidate
+  const sourceStable = metadata?.source_sha256 === treeHash('src') && metadata?.build_sha256 === treeHash('dist') &&
+    metadata?.harness_sha256 === treeHash('test/device/automated/latency') && baselineHash === treeHash(dirname(baseline))
+  const passed = !fatal && !interrupted && sourceStable && cleanup.servers && cleanup.fixture && nativeFreshness &&
+    attempts.length === 26 && attempts.every(attempt => attempt.success) && prior?.total_ms?.count === 10 && next?.total_ms?.count === 10 &&
+    next.physical_reads < prior.physical_reads && next.total_ms.p50 <= prior.total_ms.p50 && next.total_ms.p95 < prior.total_ms.p95
+  const report = { passed, fatal, interrupted, unrun_attempts: 26 - attempts.length, sourceStable, cleanup, nativeFreshness,
+    metadata, expected_fixture_activity: fixtureActivity, fixture_installed_sha256: fixtureSha, baseline: { source_sha256: baselineSource, build_sha256: baselineHash }, summaries, attempts }
+  writeFileSync('docs/benchmarks/end-to-end-latency/android-snapshot-pair.json', JSON.stringify(report, null, 2) + '\n')
+  process.exitCode = passed ? 0 : 1
+}
+
+main().catch(() => { console.error('Snapshot comparison could not write its report'); process.exitCode = 1 })

package/test/device/automated/latency-ios/benchmark.ts

@@ -0,0 +1,126 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import os from 'node:os'
+import { getIdbCmd } from '../../../../src/utils/ios/utils.js'
+import { BenchmarkSession, UnsafeMeasurement } from '../latency/end-to-end-session.js'
+import { command, treeHash } from '../latency/end-to-end-environment.js'
+import { summarizeAttempts, observationOverhead, type Attempt } from '../latency/end-to-end-report.js'
+
+const deviceId = process.env.IOS_LATENCY_DEVICE_ID
+if (!deviceId) throw new Error('Set IOS_LATENCY_DEVICE_ID to an explicit isolated, booted simulator')
+const appId = 'com.apple.Preferences'
+const smoke = process.argv.includes('--smoke')
+const rounds = smoke ? 1 : 13
+const warmups = smoke ? 0 : 3
+const cases = ['screenshot-on', 'screenshot-off', 'tree-on', 'tree-off', 'snapshot-on', 'snapshot-off']
+const attempts: Attempt[] = []
+const sessions = new Map<boolean, BenchmarkSession>()
+const phases: { phase: string; elapsed_ms: number; success: boolean }[] = []
+const startedAt = new Date().toISOString()
+const cleanup = { servers: false, settings: false }
+const controller = new AbortController()
+let fatal: string | undefined
+let sourceStable: boolean | undefined
+let metadata: Record<string, unknown> | undefined
+let startedSettings = false
+const root = 'docs/benchmarks/end-to-end-latency'
+const file = smoke ? 'ios-smoke' : 'ios-observations'
+const fingerprint = () => ({ source: treeHash('src'), build: treeHash('dist'),
+  shared_harness: treeHash('test/device/automated/latency'), ios_harness: treeHash('test/device/automated/latency-ios') })
+const identity = fingerprint()
+function idbVersion() {
+  try {
+    const interpreter = readFileSync(getIdbCmd(), 'utf8').split('\n')[0].replace(/^#!/, '').trim().split(/\s+/)
+    return command(interpreter[0], [...interpreter.slice(1), '-c', 'import importlib.metadata; print(importlib.metadata.version("fb-idb"))'])
+  } catch { return 'unavailable' }
+}
+async function phase<T>(name: string, operation: () => T | Promise<T>) {
+  const start = performance.now()
+  let success = false
+  try { const value = await operation(); success = true; return value }
+  finally { phases.push({ phase: name, elapsed_ms: performance.now() - start, success }) }
+}
+function save() {
+  mkdirSync(root, { recursive: true })
+  const summaries = summarizeAttempts(attempts)
+  const status = fatal ? 'stopped' : attempts.length === rounds * cases.length ? 'finished' : 'in_progress'
+  const outcome = fatal || attempts.some(value => !value.success) || controller.signal.aborted ? 'fail' : cleanup.servers && cleanup.settings ? 'pass' : 'pending'
+  writeFileSync(`${root}/${file}.json`, JSON.stringify({ status, outcome, started_at: startedAt,
+    performance_evidence: !smoke && sourceStable !== false, smoke, warmups, measured_attempts_per_case: smoke ? 1 : 10,
+    source_and_build_unchanged: sourceStable, identity, metadata, phases, fatal, cleanup,
+    unrun_attempts: rounds * cases.length - attempts.length,
+    invocation: `IOS_LATENCY_DEVICE_ID=[simulator] npx tsx test/device/automated/latency-ios/benchmark.ts${smoke ? ' --smoke' : ''}`,
+    summaries, observation_overhead: observationOverhead(attempts), attempts }, null, 2) + '\n')
+  const rows = Object.entries(summaries).map(([name, value]) => `| ${name} | ${value.total_ms?.count ?? 0}/${value.attempts} | ${value.total_ms?.p50.toFixed(1) ?? 'n/a'} | ${value.total_ms?.p95.toFixed(1) ?? 'n/a'} | ${value.failures} | ${value.warmup_failures} |`)
+  writeFileSync(`${root}/${file}.md`, `# iOS standalone observation ${smoke ? 'smoke (not performance evidence)' : 'baseline'}\n\nStatus: ${status}; outcome: ${outcome}. Intended screen: Settings root on an isolated simulator. No fixture journey or physical iOS claim.\n\n| Case | Successful/measured | p50 ms | p95 ms | Failures | Warm-up failures |\n| --- | ---: | ---: | ---: | ---: | ---: |\n${rows.join('\n')}\n\nSee ${file}.json for environment/build identity, all attempts, phase timings and inclusive timing diagnostics. Percentiles use the successful measured count shown for each case. With 1–19 successful samples, nearest-rank p95 is the sample maximum. Zero successful samples yield no percentiles. Failed attempts stay visible and fail the run. Probe comparisons include device variability; nested intervals cannot be summed. Application work remains in round trips. The shared #89 fixture remains required for equivalent static/network journeys.\n`)
+}
+async function sample(name: string, iteration: number) {
+  if (controller.signal.aborted) throw new UnsafeMeasurement('INTERRUPTED')
+  const value: Attempt = { case: name, iteration, warmup: iteration < warmups, success: false, setup_ms: 0, requests: [] }
+  attempts.push(value)
+  const session = sessions.get(!name.endsWith('-off'))!
+  const setupStarted = performance.now()
+  try {
+    await session.call('expect_element_visible', { platform: 'ios', selector: { text: 'Settings' }, timeout_ms: 30000, poll_interval_ms: 100 }, [])
+    value.setup_ms = performance.now() - setupStarted
+    const tool = name.startsWith('screenshot') ? 'capture_screenshot' : name.startsWith('tree') ? 'get_ui_tree' : 'capture_debug_snapshot'
+    await session.call(tool, { platform: 'ios', ...(tool === 'capture_debug_snapshot' ? { includeScreenshot: false, includeLogs: false } : {}) }, value.requests)
+    value.success = true
+  } catch (error) {
+    if (!value.setup_ms) value.setup_ms = performance.now() - setupStarted
+    value.failure = error instanceof UnsafeMeasurement ? error.message : value.requests.at(-1)?.failure ?? 'SETUP_FAILED'
+    if (error instanceof UnsafeMeasurement) throw error
+  } finally { save() }
+}
+async function main() {
+  const interrupt = () => { controller.abort(); for (const session of sessions.values()) session.abort() }
+  process.on('SIGINT', interrupt); process.on('SIGTERM', interrupt)
+  try {
+    const discovery = JSON.parse(command('xcrun', ['simctl', 'list', 'devices', 'booted', '--json']))
+    const devices = discovery.devices as Record<string, { udid: string; name: string; state: string }[]>
+    const runtime = Object.entries(devices).find(([, list]) => list.some(device => device.udid === deviceId && device.state === 'Booted'))
+    if (!runtime) throw new UnsafeMeasurement('BOOTED_SIMULATOR_REQUIRED')
+    const runtimes = JSON.parse(command('xcrun', ['simctl', 'list', 'runtimes', '--json'])).runtimes as { identifier: string; version: string; buildversion: string }[]
+    const runtimeInfo = runtimes.find(value => value.identifier === runtime[0])
+    metadata = { platform: 'ios', model: runtime[1].find(device => device.udid === deviceId)?.name,
+      runtime: runtime[0], os: runtimeInfo?.version, runtime_build: runtimeInfo?.buildversion,
+      screen: 'Settings root; English required; caller-provided isolated simulator', node: process.version,
+      host: { platform: os.platform(), release: os.release(), arch: os.arch() },
+      package_version: JSON.parse(readFileSync('package.json', 'utf8')).version,
+      commit: command('git', ['rev-parse', 'HEAD']), working_tree: command('git', ['status', '--porcelain', '--untracked-files=all']),
+      tool_versions: { xcode: command('xcodebuild', ['-version']), idb: idbVersion() },
+      timeouts: { setup_ms: 30000, call_ms: 300000, readiness_ms: 30000 },
+      journey: 'blocked: shared #89 static/network fixture unavailable', physical_ios: 'excluded' }
+    await phase('launch_settings', () => command('xcrun', ['simctl', 'launch', deviceId!, appId])); startedSettings = true
+    for (const enabled of [true, false]) {
+      const session = new BenchmarkSession(deviceId!, enabled)
+      sessions.set(enabled, session)
+      await phase(`server_startup_metrics_${enabled}`, () => session.connect())
+      await phase(`stable_screen_assertion_metrics_${enabled}`, () => session.call('expect_element_visible',
+        { platform: 'ios', selector: { text: 'Settings' }, timeout_ms: 30000, poll_interval_ms: 100 }, []))
+      if (enabled) {
+        const tree = await phase('screen_metadata', () => session.call('get_ui_tree', { platform: 'ios' }, []))
+        metadata.resolution = tree.resolution
+      }
+    }
+    save()
+    for (let iteration = 0; iteration < rounds; iteration++) for (const name of iteration % 2 ? [...cases].reverse() : cases) {
+      console.log(`${smoke ? 'smoke' : `round ${iteration + 1}/${rounds}`} ${name}`)
+      await sample(name, iteration)
+    }
+  } catch (error) { fatal = error instanceof UnsafeMeasurement ? error.message : 'PREREQUISITE_FAILED'; process.exitCode = 1 }
+  finally {
+    cleanup.servers = true
+    for (const session of sessions.values()) {
+      try { await session.close(); cleanup.servers &&= session.transport.cleanupVerified }
+      catch { cleanup.servers = false }
+    }
+    try { if (startedSettings) command('xcrun', ['simctl', 'terminate', deviceId!, appId]); cleanup.settings = true }
+    catch { cleanup.settings = false }
+    sourceStable = JSON.stringify(identity) === JSON.stringify(fingerprint())
+    if (!sourceStable) fatal = 'MEASURED_SOURCE_CHANGED'
+    if (!cleanup.servers || !cleanup.settings) fatal = 'CLEANUP_FAILED'
+    if (fatal || attempts.some(value => !value.success) || controller.signal.aborted) process.exitCode = 1
+    save(); process.off('SIGINT', interrupt); process.off('SIGTERM', interrupt)
+  }
+}
+main().catch(() => { console.error('iOS observation benchmark failed; inspect report'); process.exitCode = 1 })

package/test/device/automated/observe/correlated-evidence.smoke.ts

@@ -24,9 +24,11 @@ async function run() {
       const action = parse(await call('start_app', { ...target, appId, verificationMode: 'none', responseMode: 'compact' }))
       assert.equal(action.success, true, JSON.stringify(action))
       assert.equal(action.action_id, action.evidence.action_id)
-      assert.ok(action.evidence.dispatch_started_at_ms)
-      assert.ok(action.evidence.dispatch_completed_at_ms >= action.evidence.dispatch_started_at_ms)
-      assert.equal(action.evidence.verification_completed_at_ms, null)
+      const retained = parse(await call('get_interaction_diagnostics', { sessionId: action.diagnostics.session_id, resultId: action.diagnostics.result_id }))
+      assert.equal(retained.success, true)
+      assert.ok(retained.result.evidence.dispatch_started_at_ms)
+      assert.ok(retained.result.evidence.dispatch_completed_at_ms >= retained.result.evidence.dispatch_started_at_ms)
+      assert.equal(retained.result.evidence.verification_completed_at_ms, null)
       const actionRef = { sessionId: action.evidence.session_id, actionId: action.evidence.action_id }
       const screenResponse: any = await call('capture_screenshot', { ...target, actionRef })
       const screen = parse(screenResponse)
@@ -37,7 +39,7 @@ async function run() {
       const screenshot = screen.evidence.observations.find((v: any) => v.kind === 'screenshot')
       assert.equal(screenshot.status, 'captured')
       assert.equal(screenshot.freshness, 'fresh')
-      assert.ok(screenshot.capture_started_at_ms >= action.evidence.dispatch_completed_at_ms)
+      assert.ok(screenshot.capture_started_at_ms >= retained.result.evidence.dispatch_completed_at_ms)
       const logsResponse: any = await call('get_logs', { ...target, appId, limit: 5, actionRef })
       const logs = parse(logsResponse)
       assert.equal(logs.evidence.action_id, action.action_id)
@@ -59,7 +61,7 @@ async function run() {
       assert.equal(unassociated.evidence.action_id, null)
       console.log(JSON.stringify({ status: 'PASS', server: client.getServerVersion(), platform, device: device.id,
         osVersion: device.osVersion, startingApp: appId, actionId: action.action_id,
-        phases: { dispatchStarted: action.evidence.dispatch_started_at_ms, dispatchCompleted: action.evidence.dispatch_completed_at_ms,
+        phases: { dispatchStarted: retained.result.evidence.dispatch_started_at_ms, dispatchCompleted: retained.result.evidence.dispatch_completed_at_ms,
           screenshotStarted: screenshot.capture_started_at_ms, screenshotCompleted: screenshot.capture_completed_at_ms },
         screenshot: screenshot.status, logs: log.status, uiTree: tree.status,
         disabledComponents: 'omitted', foreignReference: 'unavailable',

package/test/device/automated/observe/device-readiness-cleanup.ts

@@ -0,0 +1,14 @@
+/** Attempt every restoration step and always close the MCP transport. */
+export async function cleanupReadinessDevice(restore: boolean, adb: (...args: string[]) => unknown, close: () => Promise<void>) {
+  const failures: unknown[] = []
+  try {
+    if (restore) {
+      for (const args of [['shell', 'input', 'keyevent', '224'], ['shell', 'wm', 'dismiss-keyguard'], ['shell', 'input', 'keyevent', '3']]) {
+        try { adb(...args) } catch (error) { failures.push(error) }
+      }
+    }
+  } finally {
+    try { await close() } catch (error) { failures.push(error) }
+  }
+  return failures
+}

package/test/device/automated/observe/device-readiness.android.smoke.ts

@@ -0,0 +1,78 @@
+import { cleanupReadinessDevice } from './device-readiness-cleanup.js'
+import assert from 'node:assert/strict'
+import { execFileSync } from 'node:child_process'
+import { writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
+
+// Opt in only on a disposable emulator; never sleep the user's physical phone.
+const deviceId = process.env.MCP_READINESS_DEVICE
+if (!deviceId) console.log('UNRUN device readiness: set MCP_READINESS_DEVICE to a disposable emulator')
+else {
+  assert.match(deviceId, /^emulator-\d+$/)
+  const adb = (...args: string[]) => execFileSync(process.env.ADB_PATH ?? 'adb', ['-s', deviceId, ...args], { encoding: 'utf8', timeout: 15000 })
+  const client = new Client({ name: 'device-readiness-smoke', version: '1.0.0' })
+  const observations: unknown[] = []
+  const call = async (name: string, args: Record<string, unknown> = {}) => {
+    const reply = await client.callTool({ name, arguments: { platform: 'android', deviceId, ...args } }, undefined, { timeout: 45000 })
+    const content = reply.content.find(item => item.type === 'text')
+    assert.ok(content?.type === 'text')
+    const result = JSON.parse(content.text)
+    observations.push({ tool: name, args, result })
+    return result
+  }
+  let restore = false
+  let journeyError: unknown
+  try {
+    await client.connect(new StdioClientTransport({ command: process.execPath, args: ['dist/server.js'], stderr: 'pipe' }))
+    const initial = await call('get_app_readiness')
+    assert.equal(initial.device_readiness.wakefulness, 'awake')
+    assert.equal(initial.device_readiness.lock_state, 'unlocked', 'start with an unlocked disposable emulator')
+    restore = true
+    adb('shell', 'input', 'keyevent', '223')
+    let sleeping = await call('get_app_readiness')
+    for (let poll = 0; sleeping.device_readiness.wakefulness === 'transitioning' && poll < 10; poll++) {
+      await new Promise(resolve => setTimeout(resolve, 100))
+      sleeping = await call('get_app_readiness')
+    }
+    assert.equal(sleeping.device_readiness.wakefulness, 'asleep')
+    assert.equal(sleeping.device_readiness.input_ready, false)
+    const launch = await call('start_app', { appId: 'com.android.settings', verificationMode: 'none', responseMode: 'compact', actionTimeoutMs: 10000 })
+    assert.equal(launch.success, true)
+    assert.equal(launch.device_readiness.input_ready, false, 'launch dispatch must not erase the blocker')
+    for (const action of [
+      { name: 'tap', args: { x: 10, y: 10 } },
+      { name: 'swipe', args: { x1: 10, y1: 10, x2: 20, y2: 20, duration: 100 } }
+    ]) {
+      const input = await call(action.name, { ...action.args, verificationMode: 'none', responseMode: 'compact', actionTimeoutMs: 10000 })
+      assert.equal(input.success, true)
+      assert.ok(input.device_readiness.blockers.includes('DEVICE_ASLEEP'), 'ordinary input retains its resolved device blocker')
+    }
+    const wait = await call('wait_for_app_ready', { timeoutMs: 1200, pollIntervalMs: 100 })
+    assert.equal(wait.success, false)
+    assert.equal(wait.failure_code, 'READINESS_TIMEOUT')
+    assert.ok(wait.device_readiness.blockers.includes('DEVICE_ASLEEP'), 'timeout retains the last observed blocker')
+    adb('shell', 'input', 'keyevent', '224')
+    const awake = await call('get_app_readiness')
+    assert.equal(awake.device_readiness.wakefulness, 'awake')
+    assert.ok(['locked', 'unlocked'].includes(awake.device_readiness.lock_state))
+    console.log(awake.device_readiness.lock_state === 'locked' ? 'PASS awake keyguard observed' : 'UNRUN real locked state: this emulator wakes unlocked; security settings were not changed')
+    // The default emulator has no passcode. Dismiss only its test keyguard to
+    // restore the explicitly required unlocked starting state.
+    adb('shell', 'wm', 'dismiss-keyguard')
+    const recovered = await call('wait_for_app_ready', { timeoutMs: 15000, stabilityMs: 100, pollIntervalMs: 100 })
+    assert.equal(recovered.success, true, JSON.stringify(recovered))
+    assert.equal(recovered.device_readiness.lock_state, 'unlocked')
+    assert.equal(recovered.device_readiness.input_ready, null)
+  } catch (error) {
+    journeyError = error
+    throw error
+  } finally {
+    const failures = await cleanupReadinessDevice(restore, adb, () => client.close())
+    if (process.env.MCP_READINESS_EVIDENCE) writeFileSync(process.env.MCP_READINESS_EVIDENCE, JSON.stringify({ deviceId, server: 'dist/server.js', server_sha256: createHash('sha256').update(readFileSync('dist/server.js')).digest('hex'), runtime: process.version, observations, cleanup: failures.length ? 'failed; all restoration steps and client close attempted' : 'wake, dismiss disposable keyguard, Home; no security settings changed' }, null, 2) + '\n')
+    if (failures.length) throw new AggregateError(journeyError ? [journeyError, ...failures] : failures, 'Device readiness cleanup failed')
+  }
+  console.log('PASS Android readiness: sleeping launch, blocked wait, awake recovery and cleanup')
+}

package/test/device/automated/observe/ios-system-trace.smoke.ts

@@ -62,8 +62,8 @@ async function run() {
     ]})
     if (!journey.success) journeyFailure = new Error(`Traced fixture input journey failed at ${journey.stopped_at_step_id}; ${journey.steps[0].result?.failure_code}`)
     else assert.equal(journey.steps[1].status,'passed')
-    assert.equal(journey.evidence.trace_context.trace_id,recording.trace_id)
-    assert.equal(journey.steps[0].result.evidence.trace_context.trace_id,recording.trace_id)
+    assert.equal(journey.evidence.trace_id,recording.trace_id)
+    assert.equal(journey.steps[0].result.evidence.trace_id,recording.trace_id)
     assert.equal(journey.system_trace.coverage,'covered');assert.ok(recording.recording_ready_at_ms<=journeySubmitted)
     const completed=await stop(recording.trace_id)
     assert.equal(completed.device.id,deviceId);assert.equal(completed.app_id,readinessAppId)

package/test/device/automated/observe/system-trace.smoke.ts

@@ -39,8 +39,8 @@ async function run() {
       ] })
     assert.equal(journey.success, true, JSON.stringify(journey))
     assert.equal(journey.steps[1].status, 'passed', 'The baseline Settings-owned UI element must remain semantically visible')
-    assert.equal(journey.evidence.trace_context.trace_id, start.trace_id)
-    assert.equal(journey.steps[0].result.evidence.trace_context.trace_id, start.trace_id)
+    assert.equal(journey.evidence.trace_id, start.trace_id)
+    assert.equal(journey.steps[0].result.evidence.trace_id, start.trace_id)
     assert.equal(journey.system_trace.coverage, 'covered')
     const stop = await call('stop_system_trace', { traceId: start.trace_id })
     if (stop.artifact) artifacts.push(stop.artifact.path)