mobile-debug-mcp 0.35.0 → 0.37.0

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

@@ -0,0 +1,119 @@
+import { verifyIosTraceShutdown } from '../../../helpers/ios-trace-shutdown.js'
+import assert from 'node:assert/strict'
+import { execFileSync } from 'node:child_process'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { createHash } from 'node:crypto'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
+import { buildReadinessFixture, readinessAppId } from '../../../fixtures/readiness-app/build.js'
+
+const inputEnvironment = () => Object.fromEntries(['IDB_COMPANION','MCP_IDB_PATH','IDB_PATH','XCRUN_PATH'].flatMap(key=>process.env[key]?[[key,process.env[key]!]]:[]))
+async function run() {
+  const deviceId=process.env.IOS_SYSTEM_TRACE_DEVICE
+  if(process.env.SKIP_DEVICE_TESTS==='1'||!deviceId){console.log('iOS system trace smoke: UNRUN (set IOS_SYSTEM_TRACE_DEVICE to an explicit simulator UDID)');return}
+  assert.equal(process.platform,'darwin')
+  const command=(args:string[])=>execFileSync('xcrun',args,{encoding:'utf8',timeout:120000,stdio:'pipe'})
+  const sims=JSON.parse(command(['simctl','list','devices','--json']))
+  const device=Object.values(sims.devices).flat().find((d:any)=>d.udid===deviceId) as any
+  assert.ok(device?.isAvailable,'Explicit available simulator required')
+  let booted=false,installed=false,fixture:ReturnType<typeof buildReadinessFixture>|undefined
+  const client=new Client({name:'ios-system-trace-smoke',version:'1.0.0'})
+  const transport=new StdioClientTransport({command:process.execPath,args:['dist/server.js'],stderr:'pipe',env:inputEnvironment()})
+  const owned=new Set<string>(),artifacts:string[]=[],checks:Record<string,unknown>={}
+  let journeyFailure: Error | undefined
+  const target={platform:'ios',deviceId},traceTarget={...target,appId:readinessAppId}
+  const call=async(name:string,args:Record<string,unknown>)=>{
+    const result=await client.callTool({name,arguments:args},undefined,{timeout:180000})
+    return JSON.parse((result.content as any[]).find(c=>c.type==='text').text)
+  }
+  const start=async(durationMs=90000)=>{
+    const r=await call('start_system_trace',{...traceTarget,durationMs})
+    if(r.trace_id&&r.cleanup?.status!=='complete')owned.add(r.trace_id)
+    assert.equal(r.state,'recording',JSON.stringify(r));assert.ok(r.recording_ready_at_ms>=r.capture_started_at_ms)
+    return r
+  }
+  const stop=async(id:string)=>{
+    const r=await call('stop_system_trace',{traceId:id})
+    if(r.artifact)artifacts.push(r.artifact.path)
+    assert.equal(r.state,'completed',JSON.stringify(r));assert.equal(r.cleanup.status,'complete')
+    assert.equal(r.artifact.validation.readable,true);owned.delete(id);return r
+  }
+  try{
+    if(device.state!=='Booted'){command(['simctl','boot',deviceId]);booted=true;command(['simctl','bootstatus',deviceId,'-b'])}
+    let preexisting=false
+    try{const existing=command(['simctl','get_app_container',deviceId,readinessAppId,'app']).trim();await fs.stat(existing);preexisting=true}catch{/* absent or stale simulator registration */}
+    assert.equal(preexisting,false,'Refuse to replace a pre-existing fixture')
+    fixture=buildReadinessFixture('ios');command(['simctl','install',deviceId,fixture.artifact]);installed=true
+    command(['simctl','launch',deviceId,readinessAppId])
+    await client.connect(transport)
+    const cap=await call('get_system_trace_capabilities',traceTarget)
+    assert.equal(cap.supported,true,JSON.stringify(cap));assert.equal(cap.prerequisites.permissions,'unknown')
+    const tree=await call('get_ui_tree',target)
+    assert.ok(tree.elements.some((e:any)=>e.text==='Ready'),'Fixture must be semantically visible')
+    assert.ok(tree.elements.some((e:any)=>e.text==='Show loader'),'Fixture button must be semantically visible')
+    const recording=await start()
+    const baselineJourney=await call('run_journey',{...target,systemTraceId:recording.trace_id,steps:[{id:'ready',type:'assert',timeoutMs:10000,assertion:{kind:'element_visible',selector:{text:'Ready'}}}]})
+    assert.equal(baselineJourney.success,true,JSON.stringify(baselineJourney));checks.linked_baseline='PASS; Ready asserted via built-server journey'
+    const journeySubmitted=Date.now()
+    const journey=await call('run_journey',{...target,systemTraceId:recording.trace_id,steps:[
+      {id:'show-loader',type:'tap',selector:{text:'Show loader'},verificationMode:'none'},
+      {id:'done',type:'assert',timeoutMs:30000,assertion:{kind:'element_visible',selector:{text:'Done'}}}
+    ]})
+    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_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)
+    assert.deepEqual(completed.correlation_ids,[baselineJourney.evidence.correlation_id,journey.evidence.correlation_id]);assert.ok(completed.artifact.validation.sample_rows>0)
+    checks.journey={status:journey.success?'PASS':'FAIL',trace_id:recording.trace_id,correlation_id:journey.evidence.correlation_id,
+      ready_at_ms:recording.recording_ready_at_ms,journey_submitted_at_ms:journeySubmitted,outcome:journey.success?'Done visible via journey UI-tree assertion':journeyFailure?.message,
+      sample_rows:completed.artifact.validation.sample_rows,artifact_bytes:completed.artifact.size_bytes,warnings:completed.warnings}
+    const stale=await call('run_journey',{...target,systemTraceId:recording.trace_id,steps:[{id:'must-not-tap',type:'tap',selector:{text:'Show loader'},verificationMode:'none'}]})
+    assert.equal(stale.error.code,'TRACE_NOT_FOUND')
+    const unchanged=await call('expect_element_visible',{...target,selector:{text:journey.success?'Done':'Ready'},timeoutMs:10000})
+    assert.ok(unchanged.success||unchanged.visible||unchanged.status==='success',JSON.stringify(unchanged))
+    checks.stale_id='PASS; rejected tap left prior fixture label visible'
+    const cancelled=await start(30000),directory=cancelled.cleanup.remaining_resources[0]
+    const cancel=await call('cancel_system_trace',{traceId:cancelled.trace_id})
+    assert.equal(cancel.state,'cancelled');assert.equal(cancel.cleanup.status,'complete');assert.equal(cancel.artifact,null);owned.delete(cancelled.trace_id)
+    await assert.rejects(()=>fs.stat(directory),{code:'ENOENT'});checks.cancel='PASS'
+    const short=await start(5000)
+    let expired=short
+    for(let i=0;i<90&&expired.state==='recording';i++){
+      await new Promise(r=>setTimeout(r,500));expired=await call('get_system_trace_status',{traceId:short.trace_id})
+    }
+    if(expired.artifact)artifacts.push(expired.artifact.path)
+    assert.equal(expired.state,'completed',JSON.stringify(expired));assert.equal(expired.completion_reason,'duration_limit');assert.equal(expired.cleanup.status,'complete');owned.delete(short.trace_id);checks.expiry='PASS'
+    const failedRecording=await start(60000)
+    const failedJourney=await call('run_journey',{...target,systemTraceId:failedRecording.trace_id,steps:[{id:'missing',type:'assert',timeoutMs:1000,assertion:{kind:'element_visible',selector:{text:'impossible-trace-fixture-label'}}}]})
+    assert.equal(failedJourney.success,false)
+    assert.equal((await call('get_system_trace_status',{traceId:failedRecording.trace_id})).state,'recording')
+    await stop(failedRecording.trace_id);checks.failed_journey='PASS; failure retained capture for explicit stop'
+    await verifyIosTraceShutdown(traceTarget,inputEnvironment());checks.shutdown='PASS; owned recording and partial directory removed'
+    const live=command(['simctl','spawn',deviceId,'launchctl','list'])
+    assert.ok(live.includes(`UIKitApplication:${readinessAppId}[`),'Recorder cleanup must leave the fixture app running')
+    checks.app_survived_cleanup='PASS'
+    const hash=createHash('sha256')
+    for(const file of ['dist/server.js','dist/observe/system-trace.js','dist/observe/system-trace-router.js','dist/observe/ios-trace/native.js','dist/observe/ios-trace/sessions.js','dist/observe/ios-trace/process.js'])hash.update(await fs.readFile(file))
+    checks.status=journeyFailure?'FAIL':'PASS';checks.build_sha256=hash.digest('hex');checks.runtime=process.version;checks.device=deviceId;checks.server=client.getServerVersion()
+    checks.physical_device='UNRUN; unsupported initial matrix';checks.native_failure_injection='UNRUN on real target; deterministic unit tests separate'
+    checks.input_toolchain=process.env.IDB_COMPANION?'Explicit test companion via IDB_COMPANION; see investigation.md':'Repository default idb companion'
+    if(journeyFailure) throw journeyFailure
+  }catch(error){checks.status='FAIL';checks.error=String(error);throw error}finally{
+    const errors:string[]=[]
+    for(const id of owned)try{const r=await call('cancel_system_trace',{traceId:id});if(r.artifact&&!artifacts.includes(r.artifact.path))artifacts.push(r.artifact.path);if(r.cleanup?.status!=='complete')errors.push(id)}catch{errors.push(id)}
+    await client.close()
+    for(const file of artifacts)await fs.rm(path.dirname(file),{recursive:true,force:true})
+    if(installed)command(['simctl','uninstall',deviceId,readinessAppId])
+    if(fixture)await fs.rm(fixture.directory,{recursive:true,force:true})
+    if(booted)command(['simctl','shutdown',deviceId])
+    checks.cleanup={trace_errors:errors,fixture_removed:installed,simulator_shutdown:booted,host_artifacts_removed:true}
+    console.log(JSON.stringify(checks))
+    if(process.env.IOS_SYSTEM_TRACE_EVIDENCE_PATH)await fs.writeFile(process.env.IOS_SYSTEM_TRACE_EVIDENCE_PATH,JSON.stringify(checks,null,2)+'\n')
+    assert.deepEqual(errors,[],'Trace cleanup failed')
+  }
+}
+run().catch(error=>{console.error(error);process.exitCode=1})

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)