agent-scenario-loop 0.1.2 → 0.1.4

package/dist/runner/profile-android.d.ts

@@ -8,8 +8,13 @@ type AndroidProfileOptions = {
 };
 type AndroidAdbProfileCommand = {
     command: string;
+    commandId?: string;
     label?: string;
+    queueId?: string;
+    sequence?: number;
+    waitForMilestone?: string;
     waitMs?: number;
+    waitTimeoutMs?: number;
 };
 type AndroidAdbDriverStep = import('./android-adb').AndroidAdbDriverStep;
 /**
@@ -30,6 +35,16 @@ declare function resolveProfileSessionCaptureWaitMs({ args, profileSessionEnable
     profileSessionEnabled: boolean;
     scenario: Record<string, any>;
 }): number;
+/**
+ * Derives a bounded logcat tail large enough to keep command-session evidence.
+ *
+ * @param {{commands: AndroidAdbProfileCommand[], profileSessionEnabled: boolean}} options
+ * @returns {number}
+ */
+declare function deriveProfileSessionLogcatLines({ commands, profileSessionEnabled, }: {
+    commands: AndroidAdbProfileCommand[];
+    profileSessionEnabled: boolean;
+}): number;
 /**
  * Expands normalized scenario evidence steps into Android adb driver actions.
  *
@@ -79,4 +94,4 @@ declare function runProfileAndroid(args: import('./profile-mobile').CliArgs, opt
  * @returns {Promise<void>}
  */
 declare function main(): Promise<void>;
-export { deriveProfileSessionCaptureWaitMs, main, parseArgs, resolveAndroidAdbProfileCommands, resolveAndroidAdbDriverSteps, resolveProfileSessionCaptureWaitMs, readAndroidAdbVideoCapturePath, validateAndroidAdbDriverSteps, runProfileAndroid, summarizeFailedAndroidChecks, usage, };
+export { deriveProfileSessionCaptureWaitMs, deriveProfileSessionLogcatLines, main, parseArgs, resolveAndroidAdbProfileCommands, resolveAndroidAdbDriverSteps, resolveProfileSessionCaptureWaitMs, readAndroidAdbVideoCapturePath, validateAndroidAdbDriverSteps, runProfileAndroid, summarizeFailedAndroidChecks, usage, };

package/dist/runner/profile-android.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.usage = exports.parseArgs = void 0;
 exports.deriveProfileSessionCaptureWaitMs = deriveProfileSessionCaptureWaitMs;
+exports.deriveProfileSessionLogcatLines = deriveProfileSessionLogcatLines;
 exports.main = main;
 exports.resolveAndroidAdbProfileCommands = resolveAndroidAdbProfileCommands;
 exports.resolveAndroidAdbDriverSteps = resolveAndroidAdbDriverSteps;
@@ -24,8 +25,27 @@ const { runAgentDeviceCapture } = require('./agent-device');
 const { loadAslLocalEnv, readStringArgOrEnv } = require('./local-env');
 const PROFILE_SESSION_CAPTURE_BOOTSTRAP_MS = 1000;
 const PROFILE_SESSION_CAPTURE_MAX_MS = 120000;
+const PROFILE_SESSION_LOGCAT_MIN_LINES = 1000;
+const PROFILE_SESSION_LOGCAT_MAX_LINES = 20000;
+const PROFILE_SESSION_LOGCAT_LINES_PER_COMMAND = 300;
 const DEFAULT_ANDROID_PROFILE_SESSION_STORAGE_KEY = 'agent-scenario-loop.profile-session.1';
 const DEFAULT_ANDROID_PROFILE_COMMAND_STORAGE_KEY = 'agent-scenario-loop.profile-commands.1';
+const DEFAULT_ANDROID_DEV_CLIENT_READY_PATTERN = 'Running "main"';
+const MANIFEST_LIFECYCLE_PHASES = new Set([
+    'cold-launch',
+    'warm-launch',
+    'hot-launch',
+    'resume',
+    'foreground',
+    'background',
+    'force-stop',
+    'process-death',
+    'scene-recreation',
+    'activity-recreation',
+    'os-reclaim',
+    'reboot',
+    'relaunch',
+]);
 /**
  * Reads and parses a JSON object from disk.
  *
@@ -54,6 +74,22 @@ function isEnabled(value) {
 function readPositiveInteger(value, fallback) {
     return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : fallback;
 }
+/**
+ * Resolves the lifecycle phase this runner is prepared to assert.
+ *
+ * @param {import('./profile-mobile').CliArgs} args
+ * @returns {string}
+ */
+function resolveManifestLifecyclePhase(args) {
+    const lifecyclePhase = readScalarArg(args['lifecycle-phase']);
+    if (lifecyclePhase === undefined) {
+        return 'cold-launch';
+    }
+    if (typeof lifecyclePhase !== 'string' || !MANIFEST_LIFECYCLE_PHASES.has(lifecyclePhase)) {
+        throw new Error(`Unsupported --lifecycle-phase "${String(lifecyclePhase)}". Expected one of ${Array.from(MANIFEST_LIFECYCLE_PHASES).join(', ')}.`);
+    }
+    return lifecyclePhase;
+}
 /**
  * Reads the number of scenario iterations that can emit app-owned truth events.
  *
@@ -119,7 +155,7 @@ function resolveAndroidPackageName({ args, config, }) {
  * @param {{config: Record<string, unknown>, action: 'start' | 'command', scenario: string, runId: string, command?: string}} options
  * @returns {string}
  */
-function buildProfileSessionUrl({ action, command, config, runId, scenario, }) {
+function buildProfileSessionUrl({ action, command, commandId, config, queueId, runId, scenario, sequence, waitForMilestone, waitMs, waitTimeoutMs, }) {
     const scheme = typeof config.app?.profileSessionScheme === 'string'
         ? config.app.profileSessionScheme
         : typeof config.app?.scheme === 'string'
@@ -128,6 +164,24 @@ function buildProfileSessionUrl({ action, command, config, runId, scenario, }) {
     const params = new URLSearchParams({ runId, scenario });
     if (action === 'command' && command) {
         params.set('command', command);
+        if (commandId) {
+            params.set('commandId', commandId);
+        }
+        if (typeof sequence === 'number') {
+            params.set('sequence', String(sequence));
+        }
+        if (queueId) {
+            params.set('queueId', queueId);
+        }
+        if (waitForMilestone) {
+            params.set('waitForMilestone', waitForMilestone);
+        }
+        if (typeof waitMs === 'number') {
+            params.set('waitMs', String(waitMs));
+        }
+        if (typeof waitTimeoutMs === 'number') {
+            params.set('waitTimeoutMs', String(waitTimeoutMs));
+        }
     }
     return `${scheme}://profile-session/${action}?${params.toString()}`;
 }
@@ -138,6 +192,23 @@ function buildProfileSessionUrl({ action, command, config, runId, scenario, }) {
  * @returns {import('./android-adb').AndroidAsyncStorageWrite[]}
  */
 function buildProfileSessionStorageWrites({ commands, commandStorageKey, commandWaitMs, runId, scenario, sessionStorageKey, }) {
+    const storedCommands = commands.map((profileCommand, index) => {
+        const timestampPlaceholder = `${ANDROID_DEVICE_EPOCH_MS_PLACEHOLDER}+${index + 1}`;
+        return {
+            id: `${scenario}-${index + 1}-${profileCommand.command}`,
+            scenario,
+            runId,
+            command: profileCommand.command,
+            ...(typeof profileCommand.commandId === 'string' ? { commandId: profileCommand.commandId } : {}),
+            ...(typeof profileCommand.sequence === 'number' ? { sequence: profileCommand.sequence } : {}),
+            ...(typeof profileCommand.queueId === 'string' ? { queueId: profileCommand.queueId } : {}),
+            ...(typeof profileCommand.waitForMilestone === 'string' ? { waitForMilestone: profileCommand.waitForMilestone } : {}),
+            ...(typeof profileCommand.waitMs === 'number' ? { waitMs: profileCommand.waitMs } : {}),
+            ...(typeof profileCommand.waitTimeoutMs === 'number' ? { waitTimeoutMs: profileCommand.waitTimeoutMs } : {}),
+            timestamp: timestampPlaceholder,
+        };
+    });
+    const commandWaitMsTotal = commands.reduce((total, profileCommand) => (total + (typeof profileCommand.waitMs === 'number' && profileCommand.waitMs > 0 ? profileCommand.waitMs : 0)), 0);
     return [
         {
             clearKeys: [commandStorageKey],
@@ -151,21 +222,14 @@ function buildProfileSessionStorageWrites({ commands, commandStorageKey, command
             }).replace(`"${ANDROID_DEVICE_EPOCH_MS_PLACEHOLDER}"`, ANDROID_DEVICE_EPOCH_MS_PLACEHOLDER),
             waitMs: commandWaitMs,
         },
-        ...commands.map((profileCommand, index) => {
-            const timestamp = Date.now() + index + 1;
-            return {
-                key: commandStorageKey,
-                label: profileCommand.label ?? `profile-command-${index + 1}`,
-                value: JSON.stringify([{
-                        id: `${timestamp}-${scenario}-${profileCommand.command}`,
-                        scenario,
-                        runId,
-                        command: profileCommand.command,
-                        timestamp,
-                    }]),
-                ...(typeof profileCommand.waitMs === 'number' ? { waitMs: profileCommand.waitMs } : {}),
-            };
-        }),
+        ...(storedCommands.length > 0
+            ? [{
+                    key: commandStorageKey,
+                    label: 'profile-command-queue',
+                    value: JSON.stringify(storedCommands),
+                    ...(commandWaitMsTotal > 0 ? { waitMs: commandWaitMsTotal } : {}),
+                }]
+            : []),
     ];
 }
 /**
@@ -218,6 +282,32 @@ function resolveProfileSessionCaptureWaitMs({ args, profileSessionEnabled, scena
     }
     return profileSessionEnabled ? deriveProfileSessionCaptureWaitMs(scenario) : 0;
 }
+/**
+ * Derives a bounded logcat tail large enough to keep command-session evidence.
+ *
+ * @param {{commands: AndroidAdbProfileCommand[], profileSessionEnabled: boolean}} options
+ * @returns {number}
+ */
+function deriveProfileSessionLogcatLines({ commands, profileSessionEnabled, }) {
+    if (!profileSessionEnabled || commands.length === 0) {
+        return PROFILE_SESSION_LOGCAT_MIN_LINES;
+    }
+    const derivedLines = PROFILE_SESSION_LOGCAT_MIN_LINES + (commands.length * PROFILE_SESSION_LOGCAT_LINES_PER_COMMAND);
+    return Math.min(Math.max(derivedLines, PROFILE_SESSION_LOGCAT_MIN_LINES), PROFILE_SESSION_LOGCAT_MAX_LINES);
+}
+/**
+ * Resolves Android logcat capture lines, keeping explicit CLI input authoritative.
+ *
+ * @param {{args: import('./profile-mobile').CliArgs, commands: AndroidAdbProfileCommand[], profileSessionEnabled: boolean}} options
+ * @returns {number}
+ */
+function resolveProfileSessionLogcatLines({ args, commands, profileSessionEnabled, }) {
+    const explicitLogcatLines = readScalarArg(args['logcat-lines']);
+    if (explicitLogcatLines !== undefined) {
+        return parsePositiveInteger(explicitLogcatLines, PROFILE_SESSION_LOGCAT_MIN_LINES);
+    }
+    return deriveProfileSessionLogcatLines({ commands, profileSessionEnabled });
+}
 /**
  * Reads Android adb adapter metadata from a normalized scenario step.
  *
@@ -271,14 +361,196 @@ function appendCaptureArg({ args, value, }) {
 function resolveExecutionPlanProfileCommands(scenario) {
     const executionPlan = buildScenarioExecutionPlan(scenario);
     const repeat = readPositiveInteger(scenario.defaultIterations, readPositiveInteger(scenario.cycles?.iterations, 1));
-    const commands = executionPlan.steps
-        .filter((step) => step.portMethod === 'executeStep' && typeof step.command === 'string')
-        .map((step) => ({
-        command: step.command,
-        label: step.id,
-        waitMs: readStepWaitMs(step),
+    const commands = [];
+    for (const [index, step] of executionPlan.steps.entries()) {
+        if (step.portMethod !== 'executeStep' || typeof step.command !== 'string') {
+            continue;
+        }
+        const nextStep = executionPlan.steps[index + 1];
+        commands.push({
+            command: step.command,
+            commandId: step.id,
+            label: step.id,
+            queueId: scenario.id ?? scenario.name,
+            waitMs: readStepWaitMs(step),
+            ...(nextStep?.portMethod === 'waitForTruthEvent' && typeof nextStep.milestone === 'string'
+                ? {
+                    waitForMilestone: resolveMilestoneEventName(scenario, nextStep.milestone),
+                    waitTimeoutMs: readPositiveInteger(nextStep.timeoutMs, 0),
+                }
+                : {}),
+        });
+    }
+    return expandProfileCommandCycles(scenario, commands, repeat);
+}
+/**
+ * Returns true when a command is part of the setup prefix that establishes app readiness before repeated cycle work.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @param {AndroidAdbProfileCommand} command
+ * @returns {boolean}
+ */
+function isReadinessSetupProfileCommand(scenario, command) {
+    if (typeof command.waitForMilestone !== 'string') {
+        return false;
+    }
+    const readyEvent = resolveScenarioReadinessEvent(scenario);
+    return typeof readyEvent === 'string' && command.waitForMilestone === readyEvent;
+}
+/**
+ * Reads a string id list from scenario cycles metadata.
+ *
+ * @param {unknown} value
+ * @returns {Set<string>}
+ */
+function readCycleStepIdSet(value) {
+    return new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : []);
+}
+/**
+ * Resolves the milestone ids that represent measured cycle boundaries.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @returns {Set<string>}
+ */
+function resolveMeasuredCycleMilestoneEvents(scenario) {
+    const milestones = new Set();
+    for (const budget of Array.isArray(scenario.budgets) ? scenario.budgets : []) {
+        if (!budget || typeof budget !== 'object' || budget.source !== 'milestone') {
+            continue;
+        }
+        if (typeof budget.fromMilestone === 'string') {
+            milestones.add(resolveMilestoneEventName(scenario, budget.fromMilestone));
+        }
+        if (typeof budget.toMilestone === 'string') {
+            milestones.add(resolveMilestoneEventName(scenario, budget.toMilestone));
+        }
+    }
+    return milestones;
+}
+/**
+ * Resolves how many leading commands are setup-only before repeated cycle work.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @param {AndroidAdbProfileCommand[]} commands
+ * @returns {number}
+ */
+function resolveSetupCommandCount(scenario, commands) {
+    const explicitSetupStepIds = readCycleStepIdSet(scenario.cycles?.setupStepIds);
+    if (explicitSetupStepIds.size > 0) {
+        let count = 0;
+        for (const command of commands) {
+            if (!command.commandId || !explicitSetupStepIds.has(command.commandId)) {
+                break;
+            }
+            count += 1;
+        }
+        return count;
+    }
+    const explicitBodyStepIds = readCycleStepIdSet(scenario.cycles?.bodyStepIds);
+    if (explicitBodyStepIds.size > 0) {
+        const firstBodyIndex = commands.findIndex((command) => (typeof command.commandId === 'string' && explicitBodyStepIds.has(command.commandId)));
+        return firstBodyIndex > 0 ? firstBodyIndex : 0;
+    }
+    let readinessSetupCommandCount = 0;
+    for (const command of commands) {
+        if (!isReadinessSetupProfileCommand(scenario, command)) {
+            break;
+        }
+        readinessSetupCommandCount += 1;
+    }
+    if (readinessSetupCommandCount > 0) {
+        return readinessSetupCommandCount;
+    }
+    const measuredMilestones = resolveMeasuredCycleMilestoneEvents(scenario);
+    if (measuredMilestones.size === 0) {
+        return 0;
+    }
+    const firstMeasuredCommandIndex = commands.findIndex((command) => (typeof command.waitForMilestone === 'string' && measuredMilestones.has(command.waitForMilestone)));
+    return firstMeasuredCommandIndex > 0 ? firstMeasuredCommandIndex : 0;
+}
+/**
+ * Expands commands so setup/readiness commands execute once while cycle-body commands repeat.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @param {AndroidAdbProfileCommand[]} commands
+ * @param {number} repeat
+ * @returns {AndroidAdbProfileCommand[]}
+ */
+function expandProfileCommandCycles(scenario, commands, repeat) {
+    const setupCommandCount = resolveSetupCommandCount(scenario, commands);
+    const setupCommands = commands.slice(0, setupCommandCount);
+    const cycleCommands = commands.slice(setupCommandCount);
+    const expandedCommands = cycleCommands.length === 0
+        ? setupCommands
+        : [
+            ...setupCommands,
+            ...Array.from({ length: repeat }).flatMap(() => cycleCommands),
+        ];
+    return expandedCommands.map((command, index) => ({
+        ...command,
+        sequence: index + 1,
     }));
-    return Array.from({ length: repeat }).flatMap(() => commands);
+}
+/**
+ * Resolves a portable milestone id to the app truth event that releases command sequencing.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @param {string} milestone
+ * @returns {string}
+ */
+function resolveMilestoneEventName(scenario, milestone) {
+    const milestoneEntry = Array.isArray(scenario.milestones)
+        ? scenario.milestones.find((entry) => entry?.id === milestone)
+        : undefined;
+    if (typeof milestoneEntry?.event === 'string' && milestoneEntry.event.length > 0) {
+        return milestoneEntry.event;
+    }
+    const metricEvent = scenario.metricEvents?.[milestone];
+    return typeof metricEvent === 'string' && metricEvent.length > 0 ? metricEvent : milestone;
+}
+/**
+ * Resolves the scenario truth event that represents initial app readiness.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @returns {string | null}
+ */
+function resolveScenarioReadinessEvent(scenario) {
+    const explicitReadyEvent = scenario.truthEvents?.ready?.event;
+    if (typeof explicitReadyEvent === 'string' && explicitReadyEvent.length > 0) {
+        return explicitReadyEvent;
+    }
+    const milestoneEntry = Array.isArray(scenario.milestones)
+        ? scenario.milestones.find((entry) => (String(entry?.event ?? '').includes('ready')))
+        : undefined;
+    return typeof milestoneEntry?.event === 'string' && milestoneEntry.event.length > 0
+        ? milestoneEntry.event
+        : null;
+}
+/**
+ * Applies wait gates from the normalized execution plan to platform-declared commands.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @param {AndroidAdbProfileCommand[]} commands
+ * @returns {AndroidAdbProfileCommand[]}
+ */
+function applyExecutionPlanCommandGates(scenario, commands) {
+    const planCommands = resolveExecutionPlanProfileCommands(scenario);
+    if (planCommands.length === 0) {
+        return commands;
+    }
+    return commands.map((command, index) => {
+        const planCommand = planCommands[index];
+        if (!planCommand || typeof planCommand.waitForMilestone !== 'string' || typeof command.waitForMilestone === 'string') {
+            return command;
+        }
+        return {
+            ...command,
+            waitForMilestone: planCommand.waitForMilestone,
+            ...(typeof command.waitTimeoutMs === 'number'
+                ? {}
+                : { waitTimeoutMs: readPositiveInteger(planCommand.waitTimeoutMs, 0) }),
+        };
+    });
 }
 /**
  * Expands normalized scenario evidence steps into Android adb driver actions.
@@ -392,12 +664,21 @@ function resolveAndroidAdbProfileCommands(scenario) {
             }
             commands.push({
                 command: command.command,
+                commandId: typeof command.id === 'string'
+                    ? command.id
+                    : typeof command.commandId === 'string'
+                        ? command.commandId
+                        : typeof command.label === 'string'
+                            ? command.label
+                            : command.command,
                 ...(typeof command.label === 'string' ? { label: command.label } : {}),
+                queueId: scenario.id ?? scenario.name,
+                sequence: commands.length + 1,
                 waitMs: readPositiveInteger(command.waitMs, 0),
             });
         }
     }
-    return commands;
+    return applyExecutionPlanCommandGates(scenario, commands);
 }
 /**
  * Summarizes failed adb capture checks for CLI errors.
@@ -459,6 +740,7 @@ function appendAgentDeviceCaptureArgs({ args, capture, }) {
 async function runProfileAndroid(args, options = {}) {
     if (!isEnabled(args['adb-capture']) && !isEnabled(args['agent-device-capture'])) {
         return runProfileMobile(args, {
+            commandTransport: typeof args.events === 'string' ? 'fixture-log-ingest' : 'adb-artifacts',
             ...(options.comparisonLane ? { comparisonLane: options.comparisonLane } : {}),
             defaultDriver: 'adb-logcat',
             ...(typeof args['adb-artifacts'] === 'string' ? { interactionDriver: 'adb-logcat' } : {}),
@@ -491,10 +773,14 @@ async function runProfileAndroid(args, options = {}) {
         'ASL_ANDROID_DEV_CLIENT_WAIT_MS',
         'ASL_EXAMPLE_ANDROID_DEV_CLIENT_WAIT_MS',
     ]), 1000);
-    const androidDevClientReadyPattern = readStringArgOrEnv(args['android-dev-client-ready-pattern'], [
+    const configuredAndroidDevClientReadyPattern = readStringArgOrEnv(args['android-dev-client-ready-pattern'], [
         'ASL_ANDROID_DEV_CLIENT_READY_PATTERN',
         'ASL_EXAMPLE_ANDROID_DEV_CLIENT_READY_PATTERN',
     ]);
+    const androidDevClientReadyPattern = configuredAndroidDevClientReadyPattern
+        ?? (androidDevClientUrl && profileSessionEnabled && profileSessionStorageEnabled
+            ? DEFAULT_ANDROID_DEV_CLIENT_READY_PATTERN
+            : undefined);
     const androidDevClientReadyQuietMs = parsePositiveInteger(readStringArgOrEnv(args['android-dev-client-ready-quiet-ms'], [
         'ASL_ANDROID_DEV_CLIENT_READY_QUIET_MS',
         'ASL_EXAMPLE_ANDROID_DEV_CLIENT_READY_QUIET_MS',
@@ -503,6 +789,10 @@ async function runProfileAndroid(args, options = {}) {
         'ASL_ANDROID_DEV_CLIENT_READY_TIMEOUT_MS',
         'ASL_EXAMPLE_ANDROID_DEV_CLIENT_READY_TIMEOUT_MS',
     ]), 60000);
+    const adbCommandTimeoutMs = parsePositiveInteger(readStringArgOrEnv(args['adb-command-timeout-ms'], [
+        'ASL_ANDROID_ADB_COMMAND_TIMEOUT_MS',
+        'ASL_EXAMPLE_ANDROID_ADB_COMMAND_TIMEOUT_MS',
+    ]), 30000);
     const scenarioName = typeof scenario.name === 'string' ? scenario.name : path.basename(args.scenario, '.json');
     const driverSteps = adbCaptureEnabled ? resolveAndroidAdbDriverSteps(scenario) : [];
     if (adbCaptureEnabled) {
@@ -530,9 +820,15 @@ async function runProfileAndroid(args, options = {}) {
                 url: buildProfileSessionUrl({
                     action: 'command',
                     command: profileCommand.command,
+                    ...(typeof profileCommand.commandId === 'string' ? { commandId: profileCommand.commandId } : {}),
                     config,
                     runId,
                     scenario: scenarioName,
+                    ...(typeof profileCommand.queueId === 'string' ? { queueId: profileCommand.queueId } : {}),
+                    ...(typeof profileCommand.sequence === 'number' ? { sequence: profileCommand.sequence } : {}),
+                    ...(typeof profileCommand.waitForMilestone === 'string' ? { waitForMilestone: profileCommand.waitForMilestone } : {}),
+                    ...(typeof profileCommand.waitMs === 'number' ? { waitMs: profileCommand.waitMs } : {}),
+                    ...(typeof profileCommand.waitTimeoutMs === 'number' ? { waitTimeoutMs: profileCommand.waitTimeoutMs } : {}),
                 }),
                 waitMs: profileCommand.waitMs,
             })),
@@ -565,13 +861,18 @@ async function runProfileAndroid(args, options = {}) {
             ...(typeof args.adb === 'string' ? { adbPath: args.adb } : {}),
             captureLogcat: true,
             clearLogcat: isEnabled(args['clear-logcat']),
+            commandTimeoutMs: adbCommandTimeoutMs,
             deepLinks: profileSessionDeepLinks,
             ...(options.delay ? { delay: options.delay } : {}),
             ...(options.executor ? { executor: options.executor } : {}),
             driverSteps,
             launch: isEnabled(args.launch),
             launchWaitMs: parsePositiveInteger(readScalarArg(args['launch-wait-ms']), 0),
-            logcatLines: parsePositiveInteger(readScalarArg(args['logcat-lines']), 1000),
+            logcatLines: resolveProfileSessionLogcatLines({
+                args,
+                commands: profileSessionCommands,
+                profileSessionEnabled,
+            }),
             outputDir: resolveAdbCaptureOutputDir({ args, runId }),
             packageName: resolveAndroidPackageName({ args, config }),
             ...(typeof args['react-native-debug-host'] === 'string'
@@ -635,9 +936,46 @@ async function runProfileAndroid(args, options = {}) {
     const profileArgs = agentDeviceCapture
         ? appendAgentDeviceCaptureArgs({ args: baseProfileArgs, capture: agentDeviceCapture })
         : baseProfileArgs;
+    const lifecyclePhase = resolveManifestLifecyclePhase(args);
+    const environmentSource = agentDeviceCapture ? 'agent-device' : 'adb';
+    const copiedAdbLogArtifact = adbCapture ? 'raw/adb-logcat.txt' : undefined;
     return runProfileMobile(profileArgs, {
+        commandTransport: profileSessionStorageEnabled
+            ? 'profile-session-storage'
+            : profileSessionEnabled
+                ? 'profile-session-deeplink'
+                : agentDeviceCapture
+                    ? 'agent-device'
+                    : 'adb-capture',
         ...(options.comparisonLane ? { comparisonLane: options.comparisonLane } : {}),
         defaultDriver: 'adb-logcat',
+        environmentPostconditions: {
+            appState: {
+                value: 'foreground',
+                evidence: 'asserted',
+                source: environmentSource,
+                ...(copiedAdbLogArtifact ? { artifact: copiedAdbLogArtifact } : {}),
+            },
+            lifecyclePhase: {
+                value: 'foreground',
+                evidence: 'asserted',
+                source: environmentSource,
+                ...(copiedAdbLogArtifact ? { artifact: copiedAdbLogArtifact } : {}),
+            },
+        },
+        environmentPreconditions: {
+            foregroundState: {
+                value: 'controlled-by-runner',
+                evidence: 'asserted',
+                source: environmentSource,
+            },
+            lifecyclePhase: {
+                value: lifecyclePhase,
+                evidence: 'asserted',
+                source: environmentSource,
+                ...(copiedAdbLogArtifact ? { artifact: copiedAdbLogArtifact } : {}),
+            },
+        },
         interactionDriver: agentDeviceCapture ? 'agent-device' : 'adb-logcat',
         platform: 'android',
     });

package/dist/runner/profile-ios.d.ts

@@ -8,8 +8,13 @@ type IosProfileOptions = {
 };
 type IosSimctlProfileCommand = {
     command: string;
+    commandId?: string;
     label?: string;
+    queueId?: string;
+    sequence?: number;
+    waitForMilestone?: string;
     waitMs?: number;
+    waitTimeoutMs?: number;
 };
 /**
  * Resolves the simctl capture output directory for a profile run.
@@ -44,15 +49,21 @@ declare function resolveIosConflictingBundleIds(config: Record<string, any>): st
  * @param {{config: Record<string, unknown>, action: 'start' | 'command', scenario: string, runId: string, command?: string}} options
  * @returns {string}
  */
-declare function buildProfileSessionUrl({ action, command, config, runId, scenario, }: {
+declare function buildProfileSessionUrl({ action, command, commandId, config, queueId, runId, scenario, sequence, waitForMilestone, waitMs, waitTimeoutMs, }: {
     action: 'start' | 'command';
     command?: string;
+    commandId?: string;
     config: Record<string, any>;
+    queueId?: string;
     runId: string;
     scenario: string;
+    sequence?: number;
+    waitForMilestone?: string;
+    waitMs?: number;
+    waitTimeoutMs?: number;
 }): string;
 /**
- * Derives a storage-backed profile capture window from scenario waits and cycles.
+ * Derives a storage-backed profile capture window from scenario waits, command gates, and cycles.
  *
  * @param {Record<string, unknown>} scenario
  * @returns {number}