mobile-debug-mcp 0.26.1 → 0.26.2

package/docs/rfcs/006-runtime-action-instrumentation-and-binding-layer.md

@@ -0,0 +1,230 @@
+# RFC 006 — Runtime Action Instrumentation & Binding Layer
+
+## 1. Summary
+
+This RFC defines how the execution model in RFC 005 is mapped onto the current runtime behaviour of the system.
+
+It does not assume a new instrumentation system exists. Instead, it describes how lifecycle semantics are derived from existing execution flows, logs, module behaviour, and lightweight runtime metadata attached to action envelopes.
+
+It specifies:
+- how existing `action_type` values are interpreted under RFC 005 semantics
+- how lifecycle states are inferred from current runtime execution
+- how `src/server` and `src/interact` currently participate in execution
+- how legacy and platform actions are incorporated into the model
+
+This RFC is a runtime binding and normalisation layer over existing implementation behaviour.
+
+---
+
+## 2. Problem Statement
+
+RFC 005 defines a unified execution lifecycle:
+- Resolved
+- Dispatched
+- Pending Verification
+- Verified
+- Failed
+
+However, the current system already contains:
+- a concrete `action_type` execution model
+- execution logic split across `src/server` and `src/interact`
+- platform-specific actions (tap_element, type_text, press_back, start_app, restart_app, scroll_to_element)
+- distributed logging and partial instrumentation within modules
+
+There is no central instrumentation system and no explicit lifecycle emitter.
+Instead, lifecycle meaning is inferred from runtime behaviour and the `lifecycle_state` / `source_module` fields now attached to action envelopes.
+
+This results in:
+- implicit execution state transitions
+- distributed observability signals
+- non-uniform traceability across actions
+
+---
+
+## 3. Design Goals
+
+This layer MUST:
+
+- Map existing runtime behaviour to RFC 005 lifecycle semantics
+- Use existing `action_type` values as the authoritative execution taxonomy
+- Derive lifecycle states from observable runtime transitions
+- Reflect actual module responsibilities (not idealised separation)
+- Work with existing logging and execution hooks
+- Preserve compatibility with all current action implementations
+
+---
+
+## 4. Runtime Execution Flow (Observed)
+
+Current observed execution flow:
+
+UI Request
+→ src/server (routing + validation)
+→ src/interact (execution + platform dispatch)
+→ platform layer
+→ response handling + logs
+→ optional state verification (where available)
+
+Lifecycle states are derived from this flow rather than explicitly emitted.
+
+---
+
+## 5. Action Type Mapping (Current Runtime)
+
+This RFC maps existing `action_type` values to RFC 005 semantics.
+
+| action_type | RFC 005 Semantic Interpretation |
+|------------|---------------------------------|
+| tap | Selection |
+| tap_element | Selection |
+| type_text | Input |
+| press_back | Navigation |
+| start_app | System Action |
+| restart_app | System Action |
+| scroll_to_element | Navigation |
+
+This table reflects the current runtime contract.
+
+---
+
+## 6. Lifecycle State Derivation
+
+Lifecycle states are NOT explicitly emitted. They are inferred as follows:
+
+### 6.1 Resolved
+Inferred when:
+- src/server accepts request
+- action is validated and normalized
+- action_id is assigned (or equivalent identifier exists)
+
+---
+
+### 6.2 Dispatched
+Inferred when:
+- control passes from src/server to src/interact
+- execution call is issued to platform layer
+
+---
+
+### 6.3 Pending Verification
+Inferred when:
+- platform execution returns a result
+- before any UI/state evaluation occurs
+
+---
+
+### 6.4 Verified / Failed
+Inferred when:
+- post-execution evaluation is performed (if available)
+
+Rules:
+- Verified = expected outcome observed in UI/state/log signals
+- Failed = timeout, error, or mismatch in expected outcome
+
+Where no formal verification exists, outcome is derived from best available signals (logs, UI diff, or absence of error).
+
+---
+
+## 7. Instrumentation Reality
+
+There is no central instrumentation layer in the current system.
+
+Instead:
+- src/server emits partial logs during routing and validation
+- src/interact emits execution logs and platform responses
+- platform adapters may emit additional debugging information
+- action envelopes now carry lightweight lifecycle metadata for post-dispatch state and source ownership
+
+Lifecycle traceability is therefore assembled from distributed signals rather than a unified event system.
+
+---
+
+## 8. Module Responsibilities (Observed Behaviour)
+
+### src/server
+- receives action requests
+- performs validation and normalization
+- assigns identifiers where applicable
+- routes actions to src/interact
+- emits partial logs for request lifecycle
+
+---
+
+### src/interact
+- executes platform-specific actions
+- handles retries and fallback behaviours
+- emits execution logs
+- returns execution results
+- may perform lightweight post-processing
+
+---
+
+## 9. Verification Reality
+
+Verification is not a uniform system-wide layer.
+
+It may occur via:
+- UI state comparison (where available)
+- log-based confirmation
+- absence of error signals
+- platform feedback
+
+Verification outcomes are best-effort only where no formal verifier exists, and deterministic where reliable state signals or explicit evaluation paths are available.
+
+---
+
+## 10. Legacy and Special Actions
+
+Actions such as:
+- scroll_to_element
+- start_app
+- restart_app
+- press_back
+
+are fully supported in the runtime.
+
+These actions:
+- may bypass full lifecycle observability
+- may not have explicit verification paths
+- are interpreted using best-effort semantic mapping
+
+---
+
+## 11. Observability Model
+
+Observability is currently distributed across:
+- src/server logs
+- src/interact logs
+- platform debug output
+- action envelope metadata
+
+There is no unified event schema.
+
+Lifecycle reconstruction requires correlation of:
+- action_type
+- timestamps
+- execution boundaries
+- error signals
+
+---
+
+## 12. Relationship to RFC 005
+
+RFC 005 defines the ideal execution lifecycle semantics.
+
+RFC 006 defines how those semantics are interpreted from the existing runtime system.
+
+Together:
+- RFC 005 = conceptual correctness model
+- RFC 006 = runtime behavioural mapping layer
+
+---
+
+## 13. Summary
+
+This RFC ensures:
+- lifecycle semantics can be derived from current runtime behaviour
+- existing action_type contract is preserved as source of truth
+- no assumption of new instrumentation infrastructure is required
+- real module responsibilities are accurately represented
+- observability is understood as distributed rather than centralised

package/docs/specs/mcp-tooling-spec-v1.md

@@ -69,6 +69,8 @@ MUST be returned in this structure:
   action_id: string,
   timestamp: string,
   action_type: string,
+  lifecycle_state?: 'pending_verification' | 'failed',
+  source_module?: 'server' | 'interact',
   target: {
     selector: object,
     resolved: object | null
@@ -87,6 +89,8 @@ Rules:
 
 - `success` is at the top level, not nested
 - `target` contains only selection and resolution context
+- `lifecycle_state` reflects the post-dispatch runtime state
+- `source_module` identifies where the envelope was produced
 - fingerprints represent observed pre/post UI state on a best-effort basis
 - `failure_code` is optional but MUST be used when a structured mapping exists
 

package/docs/tools/interact.md

@@ -36,6 +36,8 @@ Example response:
   "action_id": "tap_1710000000000_1",
   "timestamp": "2026-04-23T08:00:00.000Z",
   "action_type": "tap",
+  "lifecycle_state": "pending_verification",
+  "source_module": "server",
   "target": { "selector": { "x": 100, "y": 200 }, "resolved": null },
   "success": true,
   "ui_fingerprint_before": "fp_before",
@@ -333,6 +335,8 @@ Success response:
   "action_id": "tap_element_1710000000000_1",
   "timestamp": "2026-04-23T08:00:00.000Z",
   "action_type": "tap_element",
+  "lifecycle_state": "pending_verification",
+  "source_module": "interact",
   "target": {
     "selector": { "elementId": "el_123" },
     "resolved": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {

package/src/interact/index.ts

@@ -6,7 +6,7 @@ export { AndroidInteract, iOSInteract };
 import { resolveTargetDevice } from '../utils/resolve-device.js'
 import { ToolsObserve } from '../observe/index.js'
 import { computeSnapshotSignature } from '../observe/snapshot-metadata.js'
-import { nextActionId } from '../server/common.js'
+import { buildActionExecutionResult } from '../server/common.js'
 import type {
   ActionFailureCode,
   ActionTargetResolved,
@@ -291,27 +291,25 @@ export class ToolsInteract {
   }
 
   private static _actionFailure(
-    actionId: string,
-    timestamp: string,
     actionType: string,
     selector: Record<string, unknown> | null,
     resolved: ActionTargetResolved | null,
     failureCode: ActionFailureCode,
     retryable: boolean,
     uiFingerprintBefore: string | null,
-    uiFingerprintAfter?: string | null
+    uiFingerprintAfter?: string | null,
+    sourceModule: 'server' | 'interact' = 'interact'
   ): TapElementResponse {
-    return {
-      action_id: actionId,
-      timestamp,
-      action_type: actionType,
-      target: { selector, resolved },
+    return buildActionExecutionResult({
+      actionType,
+      selector,
+      resolved,
       success: false,
-      failure_code: failureCode,
-      retryable,
-      ui_fingerprint_before: uiFingerprintBefore,
-      ui_fingerprint_after: uiFingerprintAfter
-    }
+      uiFingerprintBefore,
+      uiFingerprintAfter: uiFingerprintAfter ?? null,
+      failure: { failureCode, retryable },
+      sourceModule
+    })
   }
 
   static _resetResolvedUiElementsForTests() {
@@ -472,14 +470,11 @@ export class ToolsInteract {
   }
 
   static async tapElementHandler({ elementId }: { elementId: string }): Promise<TapElementResponse> {
-    const timestampMs = Date.now()
-    const timestamp = new Date(timestampMs).toISOString()
     const actionType = 'tap_element'
-    const actionId = nextActionId(actionType, timestampMs)
     const selector = { elementId }
     const resolved = ToolsInteract._resolvedUiElements.get(elementId)
     if (!resolved) {
-      return ToolsInteract._actionFailure(actionId, timestamp, actionType, selector, null, 'STALE_REFERENCE', true, null)
+      return ToolsInteract._actionFailure(actionType, selector, null, 'STALE_REFERENCE', true, null)
     }
 
     const fingerprintBefore = await ToolsInteract._captureFingerprint(resolved.platform, resolved.deviceId)
@@ -491,22 +486,22 @@ export class ToolsInteract {
     const currentMatch = ToolsInteract._findCurrentResolvedElement(elements, treePlatform, treeDeviceId, resolved)
 
     if (!currentMatch) {
-      return ToolsInteract._actionFailure(actionId, timestamp, actionType, selector, null, 'STALE_REFERENCE', true, fingerprintBefore)
+      return ToolsInteract._actionFailure(actionType, selector, null, 'STALE_REFERENCE', true, fingerprintBefore)
     }
 
     const resolvedTarget = ToolsInteract._resolvedTargetFromElement(resolved.elementId, currentMatch.el, currentMatch.index)
 
     if (!ToolsInteract._isVisibleElement(currentMatch.el)) {
-      return ToolsInteract._actionFailure(actionId, timestamp, actionType, selector, resolvedTarget, 'ELEMENT_NOT_INTERACTABLE', true, fingerprintBefore)
+      return ToolsInteract._actionFailure(actionType, selector, resolvedTarget, 'ELEMENT_NOT_INTERACTABLE', true, fingerprintBefore)
     }
 
     if (currentMatch.el.enabled === false) {
-      return ToolsInteract._actionFailure(actionId, timestamp, actionType, selector, resolvedTarget, 'ELEMENT_NOT_INTERACTABLE', true, fingerprintBefore)
+      return ToolsInteract._actionFailure(actionType, selector, resolvedTarget, 'ELEMENT_NOT_INTERACTABLE', true, fingerprintBefore)
     }
 
     const bounds = ToolsInteract._normalizeBounds(currentMatch.el.bounds) ?? resolved.bounds
     if (!bounds || bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
-      return ToolsInteract._actionFailure(actionId, timestamp, actionType, selector, resolvedTarget, 'ELEMENT_NOT_INTERACTABLE', true, fingerprintBefore)
+      return ToolsInteract._actionFailure(actionType, selector, resolvedTarget, 'ELEMENT_NOT_INTERACTABLE', true, fingerprintBefore)
     }
 
     const x = Math.floor((bounds[0] + bounds[2]) / 2)
@@ -515,23 +510,20 @@ export class ToolsInteract {
 
     if (!tapResult.success) {
       const fingerprintAfterFailure = await ToolsInteract._captureFingerprint(resolved.platform, resolved.deviceId)
-      return ToolsInteract._actionFailure(actionId, timestamp, actionType, selector, resolvedTarget, 'UNKNOWN', false, fingerprintBefore, fingerprintAfterFailure)
+      return ToolsInteract._actionFailure(actionType, selector, resolvedTarget, 'UNKNOWN', false, fingerprintBefore, fingerprintAfterFailure)
     }
 
     const fingerprintAfter = await ToolsInteract._captureFingerprint(resolved.platform, resolved.deviceId)
-    return {
-      action_id: actionId,
-      timestamp,
-      action_type: actionType,
-      ...(tree?.device ? { device: tree.device } : {}),
-      target: {
-        selector,
-        resolved: resolvedTarget
-      },
+    return buildActionExecutionResult({
+      actionType,
+      device: tree?.device,
+      selector,
+      resolved: resolvedTarget,
       success: true,
-      ui_fingerprint_before: fingerprintBefore,
-      ui_fingerprint_after: fingerprintAfter
-    }
+      uiFingerprintBefore: fingerprintBefore,
+      uiFingerprintAfter: fingerprintAfter,
+      sourceModule: 'interact'
+    })
   }
 
   static async swipeHandler({ platform = 'android', x1, y1, x2, y2, duration, deviceId }: { platform?: 'android' | 'ios', x1: number, y1: number, x2: number, y2: number, duration: number, deviceId?: string }) {

package/src/server/common.ts

@@ -112,6 +112,23 @@ export function inferScrollFailure(message: string | undefined): { failureCode:
   return { failureCode: 'UNKNOWN', retryable: false }
 }
 
+const ACTION_LIFECYCLE_STATE_BY_OUTCOME = {
+  success: 'pending_verification',
+  failure: 'failed'
+} as const
+
+export function determineActionLifecycleState({
+  success,
+  failure
+}: {
+  success: boolean
+  failure?: { failureCode: ActionFailureCode; retryable: boolean }
+}): NonNullable<ActionExecutionResult['lifecycle_state']> {
+  if (failure) return ACTION_LIFECYCLE_STATE_BY_OUTCOME.failure
+  if (success) return ACTION_LIFECYCLE_STATE_BY_OUTCOME.success
+  return ACTION_LIFECYCLE_STATE_BY_OUTCOME.success
+}
+
 export function buildActionExecutionResult({
   actionType,
   device,
@@ -121,7 +138,8 @@ export function buildActionExecutionResult({
   uiFingerprintBefore,
   uiFingerprintAfter,
   failure,
-  details
+  details,
+  sourceModule
 }: {
   actionType: string
   device?: ActionExecutionResult['device']
@@ -132,6 +150,7 @@ export function buildActionExecutionResult({
   uiFingerprintAfter: string | null
   failure?: { failureCode: ActionFailureCode; retryable: boolean }
   details?: Record<string, unknown>
+  sourceModule: 'server' | 'interact'
 }): ActionExecutionResult {
   const timestampMs = Date.now()
   const timestamp = new Date(timestampMs).toISOString()
@@ -139,6 +158,8 @@ export function buildActionExecutionResult({
     action_id: nextActionId(actionType, timestampMs),
     timestamp,
     action_type: actionType,
+    lifecycle_state: determineActionLifecycleState({ success, failure }),
+    source_module: sourceModule,
     ...(device ? { device } : {}),
     target: {
       selector,

package/src/server/tool-definitions.ts

@@ -11,7 +11,9 @@ Inputs:
 
 Output Structure:
  - action_id, timestamp (ISO 8601), action_type
-- target.selector = { appId }
+ - lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+ - source_module: runtime source of the action envelope
+ - target.selector = { appId }
 - success = true when launch was dispatched successfully
 - failure_code/retryable when launch dispatch fails
 - ui_fingerprint_before/ui_fingerprint_after when available
@@ -84,7 +86,9 @@ Inputs:
 
 Output Structure:
  - action_id, timestamp (ISO 8601), action_type
-- target.selector = { appId }
+ - lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+ - source_module: runtime source of the action envelope
+ - target.selector = { appId }
 - success = true when the restart command completed
 - failure_code/retryable when restart dispatch fails
 - ui_fingerprint_before/ui_fingerprint_after when available
@@ -617,7 +621,9 @@ Inputs:
 
 Output Structure:
  - action_id, timestamp (ISO 8601), action_type
-- target.selector = { x, y }
+ - lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+ - source_module: runtime source of the action envelope
+ - target.selector = { x, y }
 - success = true when the tap was dispatched
 - failure_code/retryable when dispatch fails
 - ui_fingerprint_before/ui_fingerprint_after when available
@@ -673,6 +679,8 @@ Output Structure:
 - action_id: unique timestamp-based action identifier
 - timestamp: ISO 8601 timestamp for the action attempt
 - action_type: "tap_element"
+- lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+- source_module: runtime source of the action envelope
 - target.selector: original target handle ({ elementId })
 - target.resolved: minimal resolved element info used for the tap
 - success: true when the tap was dispatched
@@ -725,6 +733,8 @@ Inputs:
 
 Output Structure:
 - action_id, timestamp (ISO 8601), action_type
+- lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+- source_module: runtime source of the action envelope
 - target.selector = { x1, y1, x2, y2, duration }
 - success = true when the swipe was dispatched
 - failure_code/retryable when dispatch fails
@@ -777,6 +787,8 @@ Inputs:
 
 Output Structure:
 - action_id, timestamp (ISO 8601), action_type
+- lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+- source_module: runtime source of the action envelope
 - target.selector = original selector
 - target.resolved = minimal resolved element info when found
 - success = true when scrolling produced a visible target element
@@ -831,6 +843,8 @@ Inputs:
 
 Output Structure:
 - action_id, timestamp (ISO 8601), action_type
+- lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+- source_module: runtime source of the action envelope
 - target.selector = { text }
 - success = true when text input was dispatched
 - failure_code/retryable when dispatch fails
@@ -880,6 +894,8 @@ Inputs:
 
 Output Structure:
 - action_id, timestamp (ISO 8601), action_type
+- lifecycle_state: post-dispatch lifecycle state (pending_verification or failed)
+- source_module: runtime source of the action envelope
 - target.selector = { key: "back" }
 - success = true when the back action was dispatched
 - failure_code/retryable when dispatch fails

package/src/server/tool-handlers.ts

@@ -47,6 +47,7 @@ async function handleStartApp(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'start_app',
+    sourceModule: 'server',
     device: res.device,
     selector: { appId },
     success: !!res.appStarted,
@@ -82,6 +83,7 @@ async function handleRestartApp(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'restart_app',
+    sourceModule: 'server',
     device: res.device,
     selector: { appId },
     success: !!res.appRestarted,
@@ -319,6 +321,7 @@ async function handleTap(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'tap',
+    sourceModule: 'server',
     selector: { x, y },
     success: !!res.success,
     uiFingerprintBefore,
@@ -348,6 +351,7 @@ async function handleSwipe(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'swipe',
+    sourceModule: 'server',
     selector: { x1, y1, x2, y2, duration },
     success: !!res.success,
     uiFingerprintBefore,
@@ -369,6 +373,7 @@ async function handleScrollToElement(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint(platform, deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'scroll_to_element',
+    sourceModule: 'server',
     selector: selector ?? null,
     resolved: res?.success && res?.element ? {
       elementId: null,
@@ -395,6 +400,7 @@ async function handleTypeText(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint('android', deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'type_text',
+    sourceModule: 'server',
     selector: { text },
     success: !!res.success,
     uiFingerprintBefore,
@@ -411,6 +417,7 @@ async function handlePressBack(args: ToolCallArgs) {
   const uiFingerprintAfter = await captureActionFingerprint('android', deviceId)
   return wrapResponse(buildActionExecutionResult({
     actionType: 'press_back',
+    sourceModule: 'server',
     selector: { key: 'back' },
     success: !!res.success,
     uiFingerprintBefore,

package/src/server-core.ts

@@ -13,7 +13,7 @@ export { wrapResponse, toolDefinitions, handleToolCall }
 
 export const serverInfo = {
   name: 'mobile-debug-mcp',
-  version: '0.26.1'
+  version: '0.26.2'
 }
 
 export function createServer() {

package/src/types.ts

@@ -258,6 +258,8 @@ export interface ActionExecutionResult {
   action_id: string;
   timestamp: string;
   action_type: string;
+  lifecycle_state?: 'pending_verification' | 'failed';
+  source_module?: 'server' | 'interact';
   device?: DeviceInfo;
   target: {
     selector: Record<string, unknown> | null;

package/test/unit/server/response_shapes.test.ts

@@ -61,6 +61,8 @@ async function run() {
       action_id: 'tap_element_1',
       timestamp: '2026-04-23T08:00:00.000Z',
       action_type: 'tap_element',
+      lifecycle_state: 'pending_verification',
+      source_module: 'interact',
       target: {
         selector: { elementId: 'el_ready' },
         resolved: { elementId: 'el_ready', text: 'Ready', resource_id: null, accessibility_id: null, class: 'Button', bounds: [0, 0, 10, 10], index: 0 }
@@ -74,6 +76,8 @@ async function run() {
     const tapElementPayload = JSON.parse((tapElementResponse as any).content[0].text)
     assert.strictEqual(tapElementPayload.success, true)
     assert.strictEqual(tapElementPayload.action_type, 'tap_element')
+    assert.strictEqual(tapElementPayload.lifecycle_state, 'pending_verification')
+    assert.strictEqual(tapElementPayload.source_module, 'interact')
     assert.match(tapElementPayload.timestamp, /^\d{4}-\d{2}-\d{2}T/)
     assert.strictEqual(tapElementPayload.target.resolved.elementId, 'el_ready')
     assert.strictEqual(tapElementPayload.ui_fingerprint_before, 'fp_before')
@@ -84,6 +88,8 @@ async function run() {
     const tapPayload = JSON.parse((tapResponse as any).content[0].text)
     assert.strictEqual(tapPayload.success, true)
     assert.strictEqual(tapPayload.action_type, 'tap')
+    assert.strictEqual(tapPayload.lifecycle_state, 'pending_verification')
+    assert.strictEqual(tapPayload.source_module, 'server')
     assert.match(tapPayload.timestamp, /^\d{4}-\d{2}-\d{2}T/)
     assert.deepStrictEqual(tapPayload.target.selector, { x: 1, y: 2 })
     assert.strictEqual(tapPayload.ui_fingerprint_before, 'fp_mock')
@@ -107,6 +113,8 @@ async function run() {
     const startAppPayload = JSON.parse((startAppResponse as any).content[0].text)
     assert.strictEqual(startAppPayload.success, true)
     assert.strictEqual(startAppPayload.action_type, 'start_app')
+    assert.strictEqual(startAppPayload.lifecycle_state, 'pending_verification')
+    assert.strictEqual(startAppPayload.source_module, 'server')
     assert.match(startAppPayload.timestamp, /^\d{4}-\d{2}-\d{2}T/)
     assert.strictEqual(startAppPayload.device.id, 'emulator-5554')
     assert.deepStrictEqual(startAppPayload.target.selector, { appId: 'com.example.app' })