mobile-debug-mcp 0.22.0 → 0.23.0

package/dist/interact/classify.js

@@ -0,0 +1,35 @@
+/**
+ * Pure deterministic classifier. Applies rules in fixed order.
+ * Same inputs always produce the same output.
+ */
+export function classifyActionOutcome(input) {
+    const { uiChanged, expectedElementVisible, networkRequests, hasLogErrors } = input;
+    // Step 1 — UI signal is positive
+    if (uiChanged || expectedElementVisible === true) {
+        return { outcome: 'success', reasoning: expectedElementVisible === true ? 'expected element is visible' : 'UI changed after action' };
+    }
+    // Step 2 — UI did not change; network signal is required
+    if (networkRequests === null || networkRequests === undefined) {
+        return {
+            outcome: 'unknown',
+            reasoning: 'UI did not change; get_network_activity must be called before classification can proceed',
+            nextAction: 'call_get_network_activity'
+        };
+    }
+    // Step 3 — any network failure
+    const failedRequest = networkRequests.find((r) => r.status === 'failure' || r.status === 'retryable');
+    if (failedRequest) {
+        return { outcome: 'backend_failure', reasoning: `network request ${failedRequest.endpoint} returned ${failedRequest.status}` };
+    }
+    // Step 4 — no network requests at all
+    if (networkRequests.length === 0) {
+        const logNote = hasLogErrors ? ' (log errors present)' : '';
+        return { outcome: 'no_op', reasoning: `no UI change and no network activity${logNote}` };
+    }
+    // Step 5 — network requests exist and all succeeded
+    if (networkRequests.every((r) => r.status === 'success')) {
+        return { outcome: 'ui_failure', reasoning: 'network requests succeeded but UI did not change' };
+    }
+    // Step 6 — fallback
+    return { outcome: 'unknown', reasoning: 'signals are inconclusive' };
+}

package/dist/network/index.js

@@ -0,0 +1,232 @@
+import { execAdb, parseLogLine } from '../utils/android/utils.js';
+import { execCommand } from '../utils/ios/utils.js';
+// ─── Module state ─────────────────────────────────────────────────────────────
+// lastActionTimestamp: set when an action tool fires (tap, swipe, etc.)
+// lastConsumedTimestamp: advanced after each get_network_activity call to prevent duplicates
+let lastActionTimestamp = 0;
+let lastConsumedTimestamp = 0;
+export function notifyActionStart() {
+    lastActionTimestamp = Date.now();
+    lastConsumedTimestamp = 0;
+}
+/** Exposed for unit tests only. */
+export function _setTimestampsForTests(actionTs, consumedTs) {
+    lastActionTimestamp = actionTs;
+    lastConsumedTimestamp = consumedTs;
+}
+// ─── Parsing constants ────────────────────────────────────────────────────────
+const URL_RE = /https?:\/\/[^\s"'\]\)><]+/;
+const PATH_RE = /\/[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)+/;
+const METHOD_RE = /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b/;
+const NETWORK_ERROR_PATTERNS = [
+    { re: /timed?\s*out|timeout/i, code: 'timeout' },
+    { re: /dns|name[\s_]resolution|host\s*not\s*found|nodename/i, code: 'dns_error' },
+    { re: /\btls\b|\bssl\b|certificate|handshake/i, code: 'tls_error' },
+    { re: /connection\s*refused/i, code: 'connection_refused' },
+    { re: /connection\s*reset|reset\s*by\s*peer/i, code: 'connection_reset' },
+];
+const BACKGROUND_TOKENS = ['/analytics', '/metrics', '/tracking', '/log', '/events', '/telemetry', '/ping', '/beacon'];
+const BACKGROUND_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.css', '.js', '.svg', '.ico', '.woff', '.ttf'];
+const FILESYSTEM_PREFIXES = ['/data/', '/system/', '/apex/', '/proc/', '/dev/', '/vendor/', '/product/', '/storage/', '/sdcard/', '/mnt/', '/odm/', '/cache/', '/metadata/', '/acct/', '/sys/'];
+const FILESYSTEM_EXTENSIONS = ['.apk', '.apex', '.odex', '.vdex', '.dex', '.so', '.jar', '.bin', '.img', '.db', '.sqlite', '.c', '.cc', '.cpp', '.cxx', '.h', '.hpp', '.m', '.mm', '.kt', '.java', '.swift'];
+// ─── Parsing helpers ─────────────────────────────────────────────────────────
+function extractUrl(text) {
+    const m = text.match(URL_RE);
+    return m ? m[0] : null;
+}
+function isPlausibleEndpointPath(path) {
+    const lower = path.toLowerCase();
+    if (!lower.startsWith('/'))
+        return false;
+    if (FILESYSTEM_PREFIXES.some((prefix) => lower.startsWith(prefix)))
+        return false;
+    if (FILESYSTEM_EXTENSIONS.some((ext) => lower.endsWith(ext)))
+        return false;
+    return true;
+}
+function extractPath(text) {
+    const m = text.match(PATH_RE);
+    if (!m)
+        return null;
+    return isPlausibleEndpointPath(m[0]) ? m[0] : null;
+}
+function toStatusCode(value) {
+    if (!value)
+        return null;
+    const code = Number(value);
+    return code >= 100 && code <= 599 ? code : null;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function extractStatusCode(text, url, path, method) {
+    const directHttpMatch = text.match(/\bHTTP\/\d(?:\.\d)?\s+([1-5]\d{2})\b/i) || text.match(/\bHTTP\s+([1-5]\d{2})\b/i);
+    if (directHttpMatch)
+        return toStatusCode(directHttpMatch[1]);
+    const endpointToken = url || path;
+    const hasEndpointContext = endpointToken !== null;
+    if (!hasEndpointContext && method === null)
+        return null;
+    const labeledMatch = text.match(/\b(?:status(?:\s*code)?|response(?:\s*code)?)\s*[:=]?\s*([1-5]\d{2})\b/i);
+    if (labeledMatch && hasEndpointContext)
+        return toStatusCode(labeledMatch[1]);
+    if (endpointToken) {
+        const escapedEndpoint = escapeRegExp(endpointToken);
+        const endpointThenCode = new RegExp(`${escapedEndpoint}[^\\n]*?\\b([1-5]\\d{2})\\b`, 'i');
+        const codeThenEndpoint = new RegExp(`\\b([1-5]\\d{2})\\b[^\\n]*?${escapedEndpoint}`, 'i');
+        const contextualMatch = text.match(endpointThenCode) || text.match(codeThenEndpoint);
+        if (contextualMatch)
+            return toStatusCode(contextualMatch[1]);
+    }
+    if (method !== null && path !== null) {
+        const methodPathCodeMatch = text.match(/\b(?:GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b[^\n]*?\b([1-5]\d{2})\b/i);
+        if (methodPathCodeMatch)
+            return toStatusCode(methodPathCodeMatch[1]);
+    }
+    return null;
+}
+function extractMethod(text) {
+    const m = text.match(METHOD_RE);
+    return m ? m[1] : null;
+}
+function detectNetworkError(text) {
+    for (const { re, code } of NETWORK_ERROR_PATTERNS) {
+        if (re.test(text))
+            return code;
+    }
+    return null;
+}
+export function normalizeEndpoint(raw) {
+    try {
+        const u = new URL(raw.startsWith('/') ? `https://x${raw}` : raw);
+        const p = u.pathname.toLowerCase().replace(/\/+$/, '');
+        return p || '/';
+    }
+    catch {
+        return raw.toLowerCase().replace(/\?.*$/, '').replace(/\/+$/, '') || '/';
+    }
+}
+export function classifyStatus(statusCode, networkError) {
+    if (networkError !== null)
+        return 'retryable';
+    if (statusCode === null)
+        return 'success'; // request detected, no failure signal
+    if (statusCode >= 200 && statusCode <= 299)
+        return 'success';
+    if (statusCode >= 400 && statusCode <= 499)
+        return 'failure';
+    return 'retryable'; // 5xx, 1xx, 3xx
+}
+function meetsEmissionCriteria(url, path, statusCode, method) {
+    if (url !== null)
+        return true; // condition 1: full http/https URL
+    if (statusCode !== null)
+        return true; // condition 2: valid HTTP status code
+    if (method !== null && path !== null)
+        return true; // condition 3: method + path
+    return false;
+}
+function classifyEventType(endpoint) {
+    const lower = endpoint.toLowerCase();
+    if (BACKGROUND_TOKENS.some(t => lower.includes(t)))
+        return 'background';
+    if (BACKGROUND_EXTENSIONS.some(e => lower.endsWith(e)))
+        return 'background';
+    return 'primary';
+}
+function filterToSignificantEvents(events) {
+    if (events.length === 0)
+        return events;
+    const hasPrimary = events.some(e => classifyEventType(e.endpoint) === 'primary');
+    return hasPrimary ? events.filter(e => classifyEventType(e.endpoint) === 'primary') : events;
+}
+/** Exported for unit testing. */
+export function parseMessageToEvent(message) {
+    const url = extractUrl(message);
+    const path = url ? null : extractPath(message);
+    const method = extractMethod(message);
+    const statusCode = extractStatusCode(message, url, path, method);
+    const networkError = detectNetworkError(message);
+    if (!meetsEmissionCriteria(url, path, statusCode, method))
+        return null;
+    const rawEndpoint = url || path || 'unknown';
+    return {
+        endpoint: normalizeEndpoint(rawEndpoint),
+        method: method || 'unknown',
+        statusCode,
+        networkError,
+        status: classifyStatus(statusCode, networkError),
+        durationMs: 0
+    };
+}
+// ─── Android ─────────────────────────────────────────────────────────────────
+async function getAndroidEvents(sinceMs, deviceId) {
+    try {
+        const stdout = await execAdb(['logcat', '-d', '-v', 'threadtime', '*:V', '-t', '2000'], deviceId);
+        const lines = stdout ? stdout.split(/\r?\n/).filter(Boolean) : [];
+        const events = [];
+        for (const line of lines) {
+            const parsed = parseLogLine(line);
+            if (parsed._iso) {
+                const ts = new Date(parsed._iso).getTime();
+                if (ts > 0 && ts <= sinceMs)
+                    continue;
+            }
+            const event = parseMessageToEvent(parsed.message || line);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    catch {
+        return [];
+    }
+}
+// ─── iOS ─────────────────────────────────────────────────────────────────────
+async function getIOSEvents(sinceMs, deviceId = 'booted') {
+    try {
+        const lookbackSeconds = Math.max(15, Math.ceil((Date.now() - sinceMs) / 1000) + 5);
+        const args = [
+            'simctl', 'spawn', deviceId, 'log', 'show',
+            '--last', `${lookbackSeconds}s`,
+            '--style', 'syslog',
+            '--predicate', 'eventMessage contains "http" OR eventMessage contains "URLSession" OR eventMessage contains "Task <" OR eventMessage contains "HTTP/"'
+        ];
+        const result = await execCommand(args, deviceId);
+        const lines = result.output ? result.output.split(/\r?\n/).filter(Boolean) : [];
+        const events = [];
+        for (const line of lines) {
+            const tsMatch = line.match(/^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/);
+            if (tsMatch) {
+                const ts = new Date(tsMatch[1]).getTime();
+                if (ts > 0 && ts <= sinceMs)
+                    continue;
+            }
+            const event = parseMessageToEvent(line);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+export class ToolsNetwork {
+    static notifyActionStart() {
+        notifyActionStart();
+    }
+    static async getNetworkActivity(params) {
+        const { platform, deviceId } = params;
+        const sinceMs = lastConsumedTimestamp > lastActionTimestamp
+            ? lastConsumedTimestamp
+            : lastActionTimestamp > 0 ? lastActionTimestamp : Date.now() - 30000;
+        const raw = platform === 'android'
+            ? await getAndroidEvents(sinceMs, deviceId)
+            : await getIOSEvents(sinceMs, deviceId);
+        const requests = filterToSignificantEvents(raw);
+        lastConsumedTimestamp = Date.now();
+        return { requests, count: requests.length };
+    }
+}

package/dist/server-core.js

@@ -3,6 +3,8 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprot
 import { ToolsManage } from './manage/index.js';
 import { ToolsInteract } from './interact/index.js';
 import { ToolsObserve } from './observe/index.js';
+import { classifyActionOutcome } from './interact/classify.js';
+import { ToolsNetwork } from './network/index.js';
 import { AndroidManage } from './manage/index.js';
 import { iOSManage } from './manage/index.js';
 import { getSystemStatus } from './system/index.js';
@@ -478,10 +480,99 @@ export const toolDefinitions = [
                 }
             }
         }
+    },
+    {
+        name: 'classify_action_outcome',
+        description: `Classify the outcome of the most recent action into exactly one of: success, no_op, backend_failure, ui_failure, unknown.
+
+MUST be called after every action (tap, swipe, type_text, press_back, start_app, etc). Never skip.
+
+HOW TO GATHER INPUTS before calling:
+1. Call wait_for_screen_change or compare get_screen_fingerprint before/after — set uiChanged accordingly.
+2. If you checked for a specific element with wait_for_ui, set expectedElementVisible.
+3. Do NOT call get_network_activity yet — omit networkRequests on the first call.
+
+RULES (applied in order — stop at first match):
+1. If uiChanged=true OR expectedElementVisible=true → outcome=success
+2. Otherwise this tool returns nextAction="call_get_network_activity" — you MUST call get_network_activity once, then call classify_action_outcome again with the results in networkRequests.
+3. If any request has status=failure or retryable → outcome=backend_failure
+4. If no requests returned → outcome=no_op
+5. If all requests succeeded → outcome=ui_failure
+6. Otherwise → outcome=unknown
+
+BEHAVIOUR after outcome:
+- success → continue
+- no_op → retry the action once or re-resolve the element
+- backend_failure → stop and report the failing endpoint
+- ui_failure → stop and report failure
+- unknown → take one recovery step (e.g. capture_debug_snapshot), then stop`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uiChanged: {
+                    type: 'boolean',
+                    description: 'true if the screen fingerprint or activity changed after the action. Use wait_for_screen_change or compare get_screen_fingerprint before and after.'
+                },
+                expectedElementVisible: {
+                    type: 'boolean',
+                    description: 'true if the element you expected to appear is now visible (from wait_for_ui). Omit if you did not check for a specific element.'
+                },
+                networkRequests: {
+                    type: 'array',
+                    description: 'Pass this only after calling get_network_activity as instructed by nextAction. Map each request to endpoint + status.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            endpoint: { type: 'string', description: 'Request endpoint or full URL' },
+                            status: { type: 'string', enum: ['success', 'failure', 'retryable'], description: 'Outcome of the request' }
+                        },
+                        required: ['endpoint', 'status']
+                    }
+                },
+                hasLogErrors: {
+                    type: 'boolean',
+                    description: 'true if structured log errors were observed (e.g. from read_log_stream). Optional — include if you have already read logs.'
+                }
+            },
+            required: ['uiChanged']
+        }
+    },
+    {
+        name: 'get_network_activity',
+        description: `Returns structured network events captured from platform logs since the last action.
+
+Call this only when classify_action_outcome returns nextAction="call_get_network_activity".
+Do not call more than once per action.
+
+Events are filtered to significant (non-background) requests only.
+Each event includes endpoint, method, statusCode, networkError, status, and durationMs.
+
+status values:
+- success: HTTP 2xx or request detected with no error signal
+- failure: HTTP 4xx
+- retryable: HTTP 5xx, network error (timeout, dns_error, tls_error, etc.)
+
+Returns { requests: [], count: 0 } when no credible network signals are found.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                platform: {
+                    type: 'string',
+                    enum: ['android', 'ios'],
+                    description: 'Platform to read network logs from'
+                },
+                deviceId: {
+                    type: 'string',
+                    description: 'Device Serial (Android) or UDID (iOS). Defaults to connected/booted device.'
+                }
+            },
+            required: ['platform']
+        }
     }
 ];
 async function handleStartApp(args) {
     const { platform, appId, deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId));
     const response = {
         device: res.device,
@@ -498,6 +589,7 @@ async function handleTerminateApp(args) {
 }
 async function handleRestartApp(args) {
     const { platform, appId, deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await (platform === 'android' ? new AndroidManage().restartApp(appId, deviceId) : new iOSManage().restartApp(appId, deviceId));
     const response = { device: res.device, appRestarted: res.appRestarted, launchTimeMs: res.launchTimeMs };
     return wrapResponse(response);
@@ -605,31 +697,37 @@ async function handleFindElement(args) {
 }
 async function handleTap(args) {
     const { platform, x, y, deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.tapHandler({ platform, x, y, deviceId });
     return wrapResponse(res);
 }
 async function handleTapElement(args) {
     const { elementId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.tapElementHandler({ elementId });
     return wrapResponse(res);
 }
 async function handleSwipe(args) {
     const { platform = 'android', x1, y1, x2, y2, duration, deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.swipeHandler({ platform, x1, y1, x2, y2, duration, deviceId });
     return wrapResponse(res);
 }
 async function handleScrollToElement(args) {
     const { platform, selector, direction, maxScrolls, scrollAmount, deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.scrollToElementHandler({ platform, selector, direction, maxScrolls, scrollAmount, deviceId });
     return wrapResponse(res);
 }
 async function handleTypeText(args) {
     const { text, deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.typeTextHandler({ text, deviceId });
     return wrapResponse(res);
 }
 async function handlePressBack(args) {
     const { deviceId } = args;
+    ToolsNetwork.notifyActionStart();
     const res = await ToolsInteract.pressBackHandler({ deviceId });
     return wrapResponse(res);
 }
@@ -648,6 +746,21 @@ async function handleStopLogStream(args) {
     const res = await ToolsObserve.stopLogStreamHandler({ platform, sessionId });
     return wrapResponse(res);
 }
+function handleClassifyActionOutcome(args) {
+    const { uiChanged, expectedElementVisible, networkRequests, hasLogErrors } = args;
+    const result = classifyActionOutcome({
+        uiChanged: Boolean(uiChanged),
+        expectedElementVisible: expectedElementVisible ?? null,
+        networkRequests: networkRequests ?? null,
+        hasLogErrors: hasLogErrors ?? null
+    });
+    return Promise.resolve(wrapResponse(result));
+}
+async function handleGetNetworkActivity(args) {
+    const { platform, deviceId } = args;
+    const result = await ToolsNetwork.getNetworkActivity({ platform, deviceId });
+    return wrapResponse(result);
+}
 const toolHandlers = {
     start_app: handleStartApp,
     terminate_app: handleTerminateApp,
@@ -675,7 +788,9 @@ const toolHandlers = {
     press_back: handlePressBack,
     start_log_stream: handleStartLogStream,
     read_log_stream: handleReadLogStream,
-    stop_log_stream: handleStopLogStream
+    stop_log_stream: handleStopLogStream,
+    classify_action_outcome: handleClassifyActionOutcome,
+    get_network_activity: handleGetNetworkActivity
 };
 export async function handleToolCall(name, args = {}) {
     const handler = toolHandlers[name];

package/docs/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.23.0]
+- Added network monitoring
+- Added 
+
 ## [0.22.0]
 - Added a portable `test-authoring` skill package and documented the repository's vendor-neutral skill format
 - Added `AGENTS.md` as a top-level cold-start guide for autonomous agents entering the public repository

package/package.json

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

package/src/interact/classify.ts

@@ -0,0 +1,64 @@
+export type ActionOutcome = 'success' | 'no_op' | 'backend_failure' | 'ui_failure' | 'unknown'
+export type NetworkRequestStatus = 'success' | 'failure' | 'retryable'
+
+export interface NetworkRequest {
+  endpoint: string
+  status: NetworkRequestStatus
+}
+
+export interface ClassifyActionOutcomeInput {
+  uiChanged: boolean
+  expectedElementVisible?: boolean | null
+  /** null = get_network_activity has not been called yet */
+  networkRequests?: NetworkRequest[] | null
+  hasLogErrors?: boolean | null
+}
+
+export interface ClassifyActionOutcomeResult {
+  outcome: ActionOutcome
+  reasoning: string
+  /** Present when the caller must call get_network_activity before a final classification is possible */
+  nextAction?: 'call_get_network_activity'
+}
+
+/**
+ * Pure deterministic classifier. Applies rules in fixed order.
+ * Same inputs always produce the same output.
+ */
+export function classifyActionOutcome(input: ClassifyActionOutcomeInput): ClassifyActionOutcomeResult {
+  const { uiChanged, expectedElementVisible, networkRequests, hasLogErrors } = input
+
+  // Step 1 — UI signal is positive
+  if (uiChanged || expectedElementVisible === true) {
+    return { outcome: 'success', reasoning: expectedElementVisible === true ? 'expected element is visible' : 'UI changed after action' }
+  }
+
+  // Step 2 — UI did not change; network signal is required
+  if (networkRequests === null || networkRequests === undefined) {
+    return {
+      outcome: 'unknown',
+      reasoning: 'UI did not change; get_network_activity must be called before classification can proceed',
+      nextAction: 'call_get_network_activity'
+    }
+  }
+
+  // Step 3 — any network failure
+  const failedRequest = networkRequests.find((r) => r.status === 'failure' || r.status === 'retryable')
+  if (failedRequest) {
+    return { outcome: 'backend_failure', reasoning: `network request ${failedRequest.endpoint} returned ${failedRequest.status}` }
+  }
+
+  // Step 4 — no network requests at all
+  if (networkRequests.length === 0) {
+    const logNote = hasLogErrors ? ' (log errors present)' : ''
+    return { outcome: 'no_op', reasoning: `no UI change and no network activity${logNote}` }
+  }
+
+  // Step 5 — network requests exist and all succeeded
+  if (networkRequests.every((r) => r.status === 'success')) {
+    return { outcome: 'ui_failure', reasoning: 'network requests succeeded but UI did not change' }
+  }
+
+  // Step 6 — fallback
+  return { outcome: 'unknown', reasoning: 'signals are inconclusive' }
+}

package/src/network/index.ts

@@ -0,0 +1,268 @@
+import { execAdb, parseLogLine } from '../utils/android/utils.js'
+import { execCommand } from '../utils/ios/utils.js'
+
+export type NetworkErrorCode =
+  | 'timeout'
+  | 'dns_error'
+  | 'tls_error'
+  | 'connection_refused'
+  | 'connection_reset'
+  | 'unknown_network_error'
+
+export type NetworkActivityStatus = 'success' | 'failure' | 'retryable'
+
+export interface NetworkEvent {
+  endpoint: string
+  method: string
+  statusCode: number | null
+  networkError: NetworkErrorCode | null
+  status: NetworkActivityStatus
+  durationMs: number
+}
+
+export interface GetNetworkActivityResult {
+  requests: NetworkEvent[]
+  count: number
+}
+
+// ─── Module state ─────────────────────────────────────────────────────────────
+// lastActionTimestamp: set when an action tool fires (tap, swipe, etc.)
+// lastConsumedTimestamp: advanced after each get_network_activity call to prevent duplicates
+let lastActionTimestamp = 0
+let lastConsumedTimestamp = 0
+
+export function notifyActionStart(): void {
+  lastActionTimestamp = Date.now()
+  lastConsumedTimestamp = 0
+}
+
+/** Exposed for unit tests only. */
+export function _setTimestampsForTests(actionTs: number, consumedTs: number): void {
+  lastActionTimestamp = actionTs
+  lastConsumedTimestamp = consumedTs
+}
+
+// ─── Parsing constants ────────────────────────────────────────────────────────
+const URL_RE = /https?:\/\/[^\s"'\]\)><]+/
+const PATH_RE = /\/[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)+/
+const METHOD_RE = /\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b/
+
+const NETWORK_ERROR_PATTERNS: Array<{ re: RegExp; code: NetworkErrorCode }> = [
+  { re: /timed?\s*out|timeout/i, code: 'timeout' },
+  { re: /dns|name[\s_]resolution|host\s*not\s*found|nodename/i, code: 'dns_error' },
+  { re: /\btls\b|\bssl\b|certificate|handshake/i, code: 'tls_error' },
+  { re: /connection\s*refused/i, code: 'connection_refused' },
+  { re: /connection\s*reset|reset\s*by\s*peer/i, code: 'connection_reset' },
+]
+
+const BACKGROUND_TOKENS = ['/analytics', '/metrics', '/tracking', '/log', '/events', '/telemetry', '/ping', '/beacon']
+const BACKGROUND_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.css', '.js', '.svg', '.ico', '.woff', '.ttf']
+const FILESYSTEM_PREFIXES = ['/data/', '/system/', '/apex/', '/proc/', '/dev/', '/vendor/', '/product/', '/storage/', '/sdcard/', '/mnt/', '/odm/', '/cache/', '/metadata/', '/acct/', '/sys/']
+const FILESYSTEM_EXTENSIONS = ['.apk', '.apex', '.odex', '.vdex', '.dex', '.so', '.jar', '.bin', '.img', '.db', '.sqlite', '.c', '.cc', '.cpp', '.cxx', '.h', '.hpp', '.m', '.mm', '.kt', '.java', '.swift']
+
+// ─── Parsing helpers ─────────────────────────────────────────────────────────
+
+function extractUrl(text: string): string | null {
+  const m = text.match(URL_RE)
+  return m ? m[0] : null
+}
+
+function isPlausibleEndpointPath(path: string): boolean {
+  const lower = path.toLowerCase()
+  if (!lower.startsWith('/')) return false
+  if (FILESYSTEM_PREFIXES.some((prefix) => lower.startsWith(prefix))) return false
+  if (FILESYSTEM_EXTENSIONS.some((ext) => lower.endsWith(ext))) return false
+  return true
+}
+
+function extractPath(text: string): string | null {
+  const m = text.match(PATH_RE)
+  if (!m) return null
+  return isPlausibleEndpointPath(m[0]) ? m[0] : null
+}
+
+function toStatusCode(value: string | undefined): number | null {
+  if (!value) return null
+  const code = Number(value)
+  return code >= 100 && code <= 599 ? code : null
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function extractStatusCode(text: string, url: string | null, path: string | null, method: string | null): number | null {
+  const directHttpMatch = text.match(/\bHTTP\/\d(?:\.\d)?\s+([1-5]\d{2})\b/i) || text.match(/\bHTTP\s+([1-5]\d{2})\b/i)
+  if (directHttpMatch) return toStatusCode(directHttpMatch[1])
+
+  const endpointToken = url || path
+  const hasEndpointContext = endpointToken !== null
+  if (!hasEndpointContext && method === null) return null
+
+  const labeledMatch = text.match(/\b(?:status(?:\s*code)?|response(?:\s*code)?)\s*[:=]?\s*([1-5]\d{2})\b/i)
+  if (labeledMatch && hasEndpointContext) return toStatusCode(labeledMatch[1])
+
+  if (endpointToken) {
+    const escapedEndpoint = escapeRegExp(endpointToken)
+    const endpointThenCode = new RegExp(`${escapedEndpoint}[^\\n]*?\\b([1-5]\\d{2})\\b`, 'i')
+    const codeThenEndpoint = new RegExp(`\\b([1-5]\\d{2})\\b[^\\n]*?${escapedEndpoint}`, 'i')
+    const contextualMatch = text.match(endpointThenCode) || text.match(codeThenEndpoint)
+    if (contextualMatch) return toStatusCode(contextualMatch[1])
+  }
+
+  if (method !== null && path !== null) {
+    const methodPathCodeMatch = text.match(/\b(?:GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b[^\n]*?\b([1-5]\d{2})\b/i)
+    if (methodPathCodeMatch) return toStatusCode(methodPathCodeMatch[1])
+  }
+
+  return null
+}
+
+function extractMethod(text: string): string | null {
+  const m = text.match(METHOD_RE)
+  return m ? m[1] : null
+}
+
+function detectNetworkError(text: string): NetworkErrorCode | null {
+  for (const { re, code } of NETWORK_ERROR_PATTERNS) {
+    if (re.test(text)) return code
+  }
+  return null
+}
+
+export function normalizeEndpoint(raw: string): string {
+  try {
+    const u = new URL(raw.startsWith('/') ? `https://x${raw}` : raw)
+    const p = u.pathname.toLowerCase().replace(/\/+$/, '')
+    return p || '/'
+  } catch {
+    return raw.toLowerCase().replace(/\?.*$/, '').replace(/\/+$/, '') || '/'
+  }
+}
+
+export function classifyStatus(statusCode: number | null, networkError: NetworkErrorCode | null): NetworkActivityStatus {
+  if (networkError !== null) return 'retryable'
+  if (statusCode === null) return 'success' // request detected, no failure signal
+  if (statusCode >= 200 && statusCode <= 299) return 'success'
+  if (statusCode >= 400 && statusCode <= 499) return 'failure'
+  return 'retryable' // 5xx, 1xx, 3xx
+}
+
+function meetsEmissionCriteria(url: string | null, path: string | null, statusCode: number | null, method: string | null): boolean {
+  if (url !== null) return true                      // condition 1: full http/https URL
+  if (statusCode !== null) return true               // condition 2: valid HTTP status code
+  if (method !== null && path !== null) return true  // condition 3: method + path
+  return false
+}
+
+function classifyEventType(endpoint: string): 'primary' | 'background' {
+  const lower = endpoint.toLowerCase()
+  if (BACKGROUND_TOKENS.some(t => lower.includes(t))) return 'background'
+  if (BACKGROUND_EXTENSIONS.some(e => lower.endsWith(e))) return 'background'
+  return 'primary'
+}
+
+function filterToSignificantEvents(events: NetworkEvent[]): NetworkEvent[] {
+  if (events.length === 0) return events
+  const hasPrimary = events.some(e => classifyEventType(e.endpoint) === 'primary')
+  return hasPrimary ? events.filter(e => classifyEventType(e.endpoint) === 'primary') : events
+}
+
+/** Exported for unit testing. */
+export function parseMessageToEvent(message: string): NetworkEvent | null {
+  const url = extractUrl(message)
+  const path = url ? null : extractPath(message)
+  const method = extractMethod(message)
+  const statusCode = extractStatusCode(message, url, path, method)
+  const networkError = detectNetworkError(message)
+
+  if (!meetsEmissionCriteria(url, path, statusCode, method)) return null
+
+  const rawEndpoint = url || path || 'unknown'
+  return {
+    endpoint: normalizeEndpoint(rawEndpoint),
+    method: method || 'unknown',
+    statusCode,
+    networkError,
+    status: classifyStatus(statusCode, networkError),
+    durationMs: 0
+  }
+}
+
+// ─── Android ─────────────────────────────────────────────────────────────────
+
+async function getAndroidEvents(sinceMs: number, deviceId?: string): Promise<NetworkEvent[]> {
+  try {
+    const stdout = await execAdb(['logcat', '-d', '-v', 'threadtime', '*:V', '-t', '2000'], deviceId)
+    const lines = stdout ? stdout.split(/\r?\n/).filter(Boolean) : []
+
+    const events: NetworkEvent[] = []
+    for (const line of lines) {
+      const parsed = parseLogLine(line)
+      if (parsed._iso) {
+        const ts = new Date(parsed._iso).getTime()
+        if (ts > 0 && ts <= sinceMs) continue
+      }
+      const event = parseMessageToEvent(parsed.message || line)
+      if (event) events.push(event)
+    }
+    return events
+  } catch {
+    return []
+  }
+}
+
+// ─── iOS ─────────────────────────────────────────────────────────────────────
+
+async function getIOSEvents(sinceMs: number, deviceId = 'booted'): Promise<NetworkEvent[]> {
+  try {
+    const lookbackSeconds = Math.max(15, Math.ceil((Date.now() - sinceMs) / 1000) + 5)
+    const args = [
+      'simctl', 'spawn', deviceId, 'log', 'show',
+      '--last', `${lookbackSeconds}s`,
+      '--style', 'syslog',
+      '--predicate', 'eventMessage contains "http" OR eventMessage contains "URLSession" OR eventMessage contains "Task <" OR eventMessage contains "HTTP/"'
+    ]
+    const result = await execCommand(args, deviceId)
+    const lines = result.output ? result.output.split(/\r?\n/).filter(Boolean) : []
+
+    const events: NetworkEvent[] = []
+    for (const line of lines) {
+      const tsMatch = line.match(/^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/)
+      if (tsMatch) {
+        const ts = new Date(tsMatch[1]).getTime()
+        if (ts > 0 && ts <= sinceMs) continue
+      }
+      const event = parseMessageToEvent(line)
+      if (event) events.push(event)
+    }
+    return events
+  } catch {
+    return []
+  }
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export class ToolsNetwork {
+  static notifyActionStart(): void {
+    notifyActionStart()
+  }
+
+  static async getNetworkActivity(params: { platform: string; deviceId?: string }): Promise<GetNetworkActivityResult> {
+    const { platform, deviceId } = params
+
+    const sinceMs = lastConsumedTimestamp > lastActionTimestamp
+      ? lastConsumedTimestamp
+      : lastActionTimestamp > 0 ? lastActionTimestamp : Date.now() - 30000
+
+    const raw = platform === 'android'
+      ? await getAndroidEvents(sinceMs, deviceId)
+      : await getIOSEvents(sinceMs, deviceId)
+
+    const requests = filterToSignificantEvents(raw)
+    lastConsumedTimestamp = Date.now()
+
+    return { requests, count: requests.length }
+  }
+}

package/src/server-core.ts

@@ -16,6 +16,8 @@ import {
 import { ToolsManage } from './manage/index.js'
 import { ToolsInteract } from './interact/index.js'
 import { ToolsObserve } from './observe/index.js'
+import { classifyActionOutcome } from './interact/classify.js'
+import { ToolsNetwork } from './network/index.js'
 import { AndroidManage } from './manage/index.js'
 import { iOSManage } from './manage/index.js'
 import { getSystemStatus } from './system/index.js'
@@ -494,6 +496,94 @@ export const toolDefinitions = [
         }
       }
     }
+  },
+  {
+    name: 'classify_action_outcome',
+    description: `Classify the outcome of the most recent action into exactly one of: success, no_op, backend_failure, ui_failure, unknown.
+
+MUST be called after every action (tap, swipe, type_text, press_back, start_app, etc). Never skip.
+
+HOW TO GATHER INPUTS before calling:
+1. Call wait_for_screen_change or compare get_screen_fingerprint before/after — set uiChanged accordingly.
+2. If you checked for a specific element with wait_for_ui, set expectedElementVisible.
+3. Do NOT call get_network_activity yet — omit networkRequests on the first call.
+
+RULES (applied in order — stop at first match):
+1. If uiChanged=true OR expectedElementVisible=true → outcome=success
+2. Otherwise this tool returns nextAction="call_get_network_activity" — you MUST call get_network_activity once, then call classify_action_outcome again with the results in networkRequests.
+3. If any request has status=failure or retryable → outcome=backend_failure
+4. If no requests returned → outcome=no_op
+5. If all requests succeeded → outcome=ui_failure
+6. Otherwise → outcome=unknown
+
+BEHAVIOUR after outcome:
+- success → continue
+- no_op → retry the action once or re-resolve the element
+- backend_failure → stop and report the failing endpoint
+- ui_failure → stop and report failure
+- unknown → take one recovery step (e.g. capture_debug_snapshot), then stop`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        uiChanged: {
+          type: 'boolean',
+          description: 'true if the screen fingerprint or activity changed after the action. Use wait_for_screen_change or compare get_screen_fingerprint before and after.'
+        },
+        expectedElementVisible: {
+          type: 'boolean',
+          description: 'true if the element you expected to appear is now visible (from wait_for_ui). Omit if you did not check for a specific element.'
+        },
+        networkRequests: {
+          type: 'array',
+          description: 'Pass this only after calling get_network_activity as instructed by nextAction. Map each request to endpoint + status.',
+          items: {
+            type: 'object',
+            properties: {
+              endpoint: { type: 'string', description: 'Request endpoint or full URL' },
+              status: { type: 'string', enum: ['success', 'failure', 'retryable'], description: 'Outcome of the request' }
+            },
+            required: ['endpoint', 'status']
+          }
+        },
+        hasLogErrors: {
+          type: 'boolean',
+          description: 'true if structured log errors were observed (e.g. from read_log_stream). Optional — include if you have already read logs.'
+        }
+      },
+      required: ['uiChanged']
+    }
+  },
+  {
+    name: 'get_network_activity',
+    description: `Returns structured network events captured from platform logs since the last action.
+
+Call this only when classify_action_outcome returns nextAction="call_get_network_activity".
+Do not call more than once per action.
+
+Events are filtered to significant (non-background) requests only.
+Each event includes endpoint, method, statusCode, networkError, status, and durationMs.
+
+status values:
+- success: HTTP 2xx or request detected with no error signal
+- failure: HTTP 4xx
+- retryable: HTTP 5xx, network error (timeout, dns_error, tls_error, etc.)
+
+Returns { requests: [], count: 0 } when no credible network signals are found.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        platform: {
+          type: 'string',
+          enum: ['android', 'ios'],
+          description: 'Platform to read network logs from'
+        },
+        deviceId: {
+          type: 'string',
+          description: 'Device Serial (Android) or UDID (iOS). Defaults to connected/booted device.'
+        }
+      },
+      required: ['platform']
+    }
   }
 ]
 
@@ -503,6 +593,7 @@ type ToolHandler = (args: ToolCallArgs) => Promise<ToolCallResult>
 
 async function handleStartApp(args: ToolCallArgs) {
   const { platform, appId, deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId))
   const response: StartAppResponse = {
     device: res.device,
@@ -521,6 +612,7 @@ async function handleTerminateApp(args: ToolCallArgs) {
 
 async function handleRestartApp(args: ToolCallArgs) {
   const { platform, appId, deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await (platform === 'android' ? new AndroidManage().restartApp(appId, deviceId) : new iOSManage().restartApp(appId, deviceId))
   const response: RestartAppResponse = { device: res.device, appRestarted: res.appRestarted, launchTimeMs: res.launchTimeMs }
   return wrapResponse(response)
@@ -644,36 +736,42 @@ async function handleFindElement(args: ToolCallArgs) {
 
 async function handleTap(args: ToolCallArgs) {
   const { platform, x, y, deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await ToolsInteract.tapHandler({ platform, x, y, deviceId })
   return wrapResponse(res)
 }
 
 async function handleTapElement(args: ToolCallArgs) {
   const { elementId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await ToolsInteract.tapElementHandler({ elementId })
   return wrapResponse(res)
 }
 
 async function handleSwipe(args: ToolCallArgs) {
   const { platform = 'android', x1, y1, x2, y2, duration, deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await ToolsInteract.swipeHandler({ platform, x1, y1, x2, y2, duration, deviceId })
   return wrapResponse(res)
 }
 
 async function handleScrollToElement(args: ToolCallArgs) {
   const { platform, selector, direction, maxScrolls, scrollAmount, deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await ToolsInteract.scrollToElementHandler({ platform, selector, direction, maxScrolls, scrollAmount, deviceId })
   return wrapResponse(res)
 }
 
 async function handleTypeText(args: ToolCallArgs) {
   const { text, deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await ToolsInteract.typeTextHandler({ text, deviceId })
   return wrapResponse(res)
 }
 
 async function handlePressBack(args: ToolCallArgs) {
   const { deviceId } = args as any
+  ToolsNetwork.notifyActionStart()
   const res = await ToolsInteract.pressBackHandler({ deviceId })
   return wrapResponse(res)
 }
@@ -696,6 +794,23 @@ async function handleStopLogStream(args: ToolCallArgs) {
   return wrapResponse(res)
 }
 
+function handleClassifyActionOutcome(args: ToolCallArgs) {
+  const { uiChanged, expectedElementVisible, networkRequests, hasLogErrors } = args as any
+  const result = classifyActionOutcome({
+    uiChanged: Boolean(uiChanged),
+    expectedElementVisible: expectedElementVisible ?? null,
+    networkRequests: networkRequests ?? null,
+    hasLogErrors: hasLogErrors ?? null
+  })
+  return Promise.resolve(wrapResponse(result))
+}
+
+async function handleGetNetworkActivity(args: ToolCallArgs) {
+  const { platform, deviceId } = args as any
+  const result = await ToolsNetwork.getNetworkActivity({ platform, deviceId })
+  return wrapResponse(result)
+}
+
 const toolHandlers: Record<string, ToolHandler> = {
   start_app: handleStartApp,
   terminate_app: handleTerminateApp,
@@ -723,7 +838,9 @@ const toolHandlers: Record<string, ToolHandler> = {
   press_back: handlePressBack,
   start_log_stream: handleStartLogStream,
   read_log_stream: handleReadLogStream,
-  stop_log_stream: handleStopLogStream
+  stop_log_stream: handleStopLogStream,
+  classify_action_outcome: handleClassifyActionOutcome,
+  get_network_activity: handleGetNetworkActivity
 }
 
 export async function handleToolCall(name: string, args: ToolCallArgs = {}) {

package/test/unit/interact/classify_action_outcome.test.ts

@@ -0,0 +1,110 @@
+import assert from 'assert'
+import { classifyActionOutcome } from '../../../src/interact/classify.js'
+
+function run() {
+  // Step 1 — uiChanged → success
+  {
+    const result = classifyActionOutcome({ uiChanged: true })
+    assert.strictEqual(result.outcome, 'success')
+    assert.ok(result.reasoning.length > 0)
+    assert.strictEqual(result.nextAction, undefined)
+  }
+
+  // Step 1 — expectedElementVisible → success
+  {
+    const result = classifyActionOutcome({ uiChanged: false, expectedElementVisible: true })
+    assert.strictEqual(result.outcome, 'success')
+    assert.strictEqual(result.reasoning, 'expected element is visible')
+    assert.strictEqual(result.nextAction, undefined)
+  }
+
+  // Step 1 — both uiChanged and expectedElementVisible → success
+  {
+    const result = classifyActionOutcome({ uiChanged: true, expectedElementVisible: true })
+    assert.strictEqual(result.outcome, 'success')
+  }
+
+  // Step 2 — UI did not change, networkRequests not yet provided → nextAction required
+  {
+    const result = classifyActionOutcome({ uiChanged: false })
+    assert.strictEqual(result.outcome, 'unknown')
+    assert.strictEqual(result.nextAction, 'call_get_network_activity')
+  }
+
+  // Step 2 — explicit null networkRequests → nextAction required
+  {
+    const result = classifyActionOutcome({ uiChanged: false, expectedElementVisible: null, networkRequests: null })
+    assert.strictEqual(result.outcome, 'unknown')
+    assert.strictEqual(result.nextAction, 'call_get_network_activity')
+  }
+
+  // Step 3 — failure status → backend_failure
+  {
+    const result = classifyActionOutcome({
+      uiChanged: false,
+      networkRequests: [{ endpoint: '/login', status: 'failure' }]
+    })
+    assert.strictEqual(result.outcome, 'backend_failure')
+    assert.ok(result.reasoning.includes('/login'))
+    assert.ok(result.reasoning.includes('failure'))
+  }
+
+  // Step 3 — retryable status → backend_failure
+  {
+    const result = classifyActionOutcome({
+      uiChanged: false,
+      networkRequests: [
+        { endpoint: '/api/submit', status: 'retryable' },
+        { endpoint: '/api/other', status: 'success' }
+      ]
+    })
+    assert.strictEqual(result.outcome, 'backend_failure')
+    assert.ok(result.reasoning.includes('/api/submit'))
+  }
+
+  // Step 4 — empty network requests → no_op
+  {
+    const result = classifyActionOutcome({ uiChanged: false, networkRequests: [] })
+    assert.strictEqual(result.outcome, 'no_op')
+    assert.ok(result.reasoning.includes('no UI change'))
+    assert.ok(result.reasoning.includes('no network activity'))
+  }
+
+  // Step 4 — empty network requests with log errors → no_op with note
+  {
+    const result = classifyActionOutcome({ uiChanged: false, networkRequests: [], hasLogErrors: true })
+    assert.strictEqual(result.outcome, 'no_op')
+    assert.ok(result.reasoning.includes('log errors'))
+  }
+
+  // Step 5 — all requests succeeded but UI unchanged → ui_failure
+  {
+    const result = classifyActionOutcome({
+      uiChanged: false,
+      networkRequests: [
+        { endpoint: '/api/save', status: 'success' },
+        { endpoint: '/api/refresh', status: 'success' }
+      ]
+    })
+    assert.strictEqual(result.outcome, 'ui_failure')
+    assert.ok(result.reasoning.includes('network requests succeeded'))
+  }
+
+  // Step 1 takes priority over network signals — success even when failures present
+  {
+    const result = classifyActionOutcome({
+      uiChanged: true,
+      networkRequests: [{ endpoint: '/api/log', status: 'failure' }]
+    })
+    assert.strictEqual(result.outcome, 'success')
+  }
+
+  console.log('classify_action_outcome tests passed')
+}
+
+try {
+  run()
+} catch (error) {
+  console.error(error)
+  process.exit(1)
+}

package/test/unit/network/get_network_activity.test.ts

@@ -0,0 +1,181 @@
+import assert from 'assert'
+import {
+  parseMessageToEvent,
+  normalizeEndpoint,
+  classifyStatus,
+  _setTimestampsForTests,
+  ToolsNetwork
+} from '../../../src/network/index.js'
+
+function run() {
+
+  // ─── normalizeEndpoint ──────────────────────────────────────────────────────
+
+  {
+    const r = normalizeEndpoint('https://api.example.com/v1/users?page=2')
+    assert.strictEqual(r, '/v1/users', `normalizeEndpoint full URL: expected /v1/users, got ${r}`)
+  }
+
+  {
+    const r = normalizeEndpoint('/api/login/')
+    assert.strictEqual(r, '/api/login', `normalizeEndpoint path trailing slash: expected /api/login, got ${r}`)
+  }
+
+  {
+    const r = normalizeEndpoint('/Api/Login')
+    assert.strictEqual(r, '/api/login', `normalizeEndpoint uppercase: expected /api/login, got ${r}`)
+  }
+
+  // ─── classifyStatus ─────────────────────────────────────────────────────────
+
+  {
+    const s = classifyStatus(200, null)
+    assert.strictEqual(s, 'success', `200 should be success`)
+  }
+
+  {
+    const s = classifyStatus(404, null)
+    assert.strictEqual(s, 'failure', `404 should be failure`)
+  }
+
+  {
+    const s = classifyStatus(500, null)
+    assert.strictEqual(s, 'retryable', `500 should be retryable`)
+  }
+
+  {
+    const s = classifyStatus(null, 'timeout')
+    assert.strictEqual(s, 'retryable', `networkError should override to retryable`)
+  }
+
+  {
+    const s = classifyStatus(200, 'connection_reset')
+    assert.strictEqual(s, 'retryable', `networkError beats statusCode`)
+  }
+
+  {
+    const s = classifyStatus(null, null)
+    assert.strictEqual(s, 'success', `null/null (request detected, no error) = success`)
+  }
+
+  // ─── parseMessageToEvent — emission criteria ─────────────────────────────────
+
+  // Condition 1: full URL
+  {
+    const e = parseMessageToEvent('OkHttp: GET https://api.example.com/v1/login 200')
+    assert.ok(e !== null, 'full URL line should emit')
+    assert.strictEqual(e!.endpoint, '/v1/login')
+    assert.strictEqual(e!.method, 'GET')
+    assert.strictEqual(e!.statusCode, 200)
+    assert.strictEqual(e!.status, 'success')
+  }
+
+  // Condition 2: explicit HTTP status line
+  {
+    const e = parseMessageToEvent('HTTP/1.1 404 Not Found')
+    assert.ok(e !== null, 'HTTP status line should emit')
+    assert.strictEqual(e!.statusCode, 404)
+    assert.strictEqual(e!.status, 'failure')
+  }
+
+  // Condition 3: method + path
+  {
+    const e = parseMessageToEvent('Sending POST /api/register HTTP/1.1')
+    assert.ok(e !== null, 'method+path line should emit')
+    assert.strictEqual(e!.method, 'POST')
+    assert.strictEqual(e!.endpoint, '/api/register')
+    assert.strictEqual(e!.statusCode, null)
+    assert.strictEqual(e!.status, 'success') // no error signal
+  }
+
+  // No criteria met — keyword-only noise
+  {
+    const e = parseMessageToEvent('HTTP connection pool initialised')
+    assert.strictEqual(e, null, 'keyword-only line should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('Request interceptor registered')
+    assert.strictEqual(e, null, 'generic Request line should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('Task 200 completed')
+    assert.strictEqual(e, null, 'bare status-like numbers should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('Response code: 404')
+    assert.strictEqual(e, null, 'labeled status without endpoint or HTTP context should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('GetBestInfo: /data/app/~~pkg/base.apk status=447')
+    assert.strictEqual(e, null, 'filesystem paths should not emit as network endpoints')
+  }
+
+  {
+    const e = parseMessageToEvent('system/gd/hci/le_address_manager.cc:576 GetNextPrivateAddressIntervalRange')
+    assert.strictEqual(e, null, 'source file paths should not emit as network endpoints')
+  }
+
+  {
+    const e = parseMessageToEvent('status=503 for /api/session/generate')
+    assert.ok(e !== null, 'status with plausible endpoint should emit')
+    assert.strictEqual(e!.endpoint, '/api/session/generate')
+    assert.strictEqual(e!.statusCode, 503)
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  // Network error detection
+  {
+    const e = parseMessageToEvent('java.net.SocketTimeoutException: POST /api/data timed out after 30s')
+    assert.ok(e !== null, 'timeout error should emit')
+    assert.strictEqual(e!.networkError, 'timeout')
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  {
+    const e = parseMessageToEvent('SSL handshake failed for https://api.example.com/v1/auth')
+    assert.ok(e !== null, 'TLS error should emit')
+    assert.strictEqual(e!.networkError, 'tls_error')
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  {
+    const e = parseMessageToEvent('DNS resolution failed: GET /api/users')
+    assert.ok(e !== null, 'DNS error should emit')
+    assert.strictEqual(e!.networkError, 'dns_error')
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  // 5xx → retryable even without networkError
+  {
+    const e = parseMessageToEvent('Response 503 for https://api.example.com/v1/data')
+    assert.ok(e !== null, '5xx should emit')
+    assert.strictEqual(e!.statusCode, 503)
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  // ─── lastConsumedTimestamp dedupe ────────────────────────────────────────────
+
+  {
+    // Simulate: action happened 1000ms ago, last consumed 500ms ago → use consumed
+    _setTimestampsForTests(Date.now() - 1000, Date.now() - 500)
+    // We can't easily verify the sinceMs value from outside without deep mocking,
+    // but we can confirm getNetworkActivity resolves without throwing.
+    const promise = ToolsNetwork.getNetworkActivity({ platform: 'android' })
+    assert.ok(promise instanceof Promise, 'getNetworkActivity should return a Promise')
+    // Allow the promise to settle (logcat may fail in test env — that's fine)
+    promise.catch(() => {})
+  }
+
+  console.log('get_network_activity tests passed')
+}
+
+try {
+  run()
+} catch (err) {
+  console.error(err)
+  process.exit(1)
+}