agent-scenario-loop 0.1.3 → 0.1.4

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

@@ -50,6 +50,7 @@ type IosProfileSessionStorageCommand = {
     sequence?: number;
     timestamp?: number;
     waitForMilestone?: string;
+    waitMs?: number;
     waitTimeoutMs?: number;
 };
 type IosProfileSessionStorageSeed = {

package/dist/runner/ios-simctl.js

@@ -462,6 +462,7 @@ async function seedProfileSessionStorage({ bundleId, commands = [], dataContaine
         ...(typeof profileCommand.sequence === 'number' ? { sequence: profileCommand.sequence } : {}),
         timestamp: typeof profileCommand.timestamp === 'number' ? profileCommand.timestamp : startedAt + index + 1,
         ...(typeof profileCommand.waitForMilestone === 'string' ? { waitForMilestone: profileCommand.waitForMilestone } : {}),
+        ...(typeof profileCommand.waitMs === 'number' ? { waitMs: profileCommand.waitMs } : {}),
         ...(typeof profileCommand.waitTimeoutMs === 'number' ? { waitTimeoutMs: profileCommand.waitTimeoutMs } : {}),
     }));
     manifest[profileStorageKeys.session] = JSON.stringify(session);

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

@@ -35,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.
  *
@@ -84,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,12 @@ 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',
@@ -150,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, commandId, config, queueId, runId, scenario, sequence, waitForMilestone, waitTimeoutMs, }) {
+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'
@@ -171,6 +176,9 @@ function buildProfileSessionUrl({ action, command, commandId, config, queueId, r
         if (waitForMilestone) {
             params.set('waitForMilestone', waitForMilestone);
         }
+        if (typeof waitMs === 'number') {
+            params.set('waitMs', String(waitMs));
+        }
         if (typeof waitTimeoutMs === 'number') {
             params.set('waitTimeoutMs', String(waitTimeoutMs));
         }
@@ -184,11 +192,10 @@ function buildProfileSessionUrl({ action, command, commandId, config, queueId, r
  * @returns {import('./android-adb').AndroidAsyncStorageWrite[]}
  */
 function buildProfileSessionStorageWrites({ commands, commandStorageKey, commandWaitMs, runId, scenario, sessionStorageKey, }) {
-    const timestampBase = Date.now();
     const storedCommands = commands.map((profileCommand, index) => {
-        const timestamp = timestampBase + index + 1;
+        const timestampPlaceholder = `${ANDROID_DEVICE_EPOCH_MS_PLACEHOLDER}+${index + 1}`;
         return {
-            id: `${timestamp}-${scenario}-${profileCommand.command}`,
+            id: `${scenario}-${index + 1}-${profileCommand.command}`,
             scenario,
             runId,
             command: profileCommand.command,
@@ -196,8 +203,9 @@ function buildProfileSessionStorageWrites({ commands, commandStorageKey, command
             ...(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,
+            timestamp: timestampPlaceholder,
         };
     });
     const commandWaitMsTotal = commands.reduce((total, profileCommand) => (total + (typeof profileCommand.waitMs === 'number' && profileCommand.waitMs > 0 ? profileCommand.waitMs : 0)), 0);
@@ -274,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.
  *
@@ -341,16 +375,182 @@ function resolveExecutionPlanProfileCommands(scenario) {
             waitMs: readStepWaitMs(step),
             ...(nextStep?.portMethod === 'waitForTruthEvent' && typeof nextStep.milestone === 'string'
                 ? {
-                    waitForMilestone: nextStep.milestone,
+                    waitForMilestone: resolveMilestoneEventName(scenario, nextStep.milestone),
                     waitTimeoutMs: readPositiveInteger(nextStep.timeoutMs, 0),
                 }
                 : {}),
         });
     }
-    return Array.from({ length: repeat }).flatMap((_, iteration) => commands.map((command, commandIndex) => ({
+    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: (iteration * commands.length) + commandIndex + 1,
-    })));
+        sequence: index + 1,
+    }));
+}
+/**
+ * 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.
@@ -478,7 +678,7 @@ function resolveAndroidAdbProfileCommands(scenario) {
             });
         }
     }
-    return commands;
+    return applyExecutionPlanCommandGates(scenario, commands);
 }
 /**
  * Summarizes failed adb capture checks for CLI errors.
@@ -573,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',
@@ -585,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) {
@@ -619,6 +827,7 @@ async function runProfileAndroid(args, options = {}) {
                     ...(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,
@@ -652,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'
@@ -724,7 +938,7 @@ async function runProfileAndroid(args, options = {}) {
         : baseProfileArgs;
     const lifecyclePhase = resolveManifestLifecyclePhase(args);
     const environmentSource = agentDeviceCapture ? 'agent-device' : 'adb';
-    const lifecycleArtifact = adbCapture ? 'raw/adb-logcat.txt' : 'raw/interaction.log';
+    const copiedAdbLogArtifact = adbCapture ? 'raw/adb-logcat.txt' : undefined;
     return runProfileMobile(profileArgs, {
         commandTransport: profileSessionStorageEnabled
             ? 'profile-session-storage'
@@ -740,13 +954,13 @@ async function runProfileAndroid(args, options = {}) {
                 value: 'foreground',
                 evidence: 'asserted',
                 source: environmentSource,
-                artifact: lifecycleArtifact,
+                ...(copiedAdbLogArtifact ? { artifact: copiedAdbLogArtifact } : {}),
             },
             lifecyclePhase: {
                 value: 'foreground',
                 evidence: 'asserted',
                 source: environmentSource,
-                artifact: lifecycleArtifact,
+                ...(copiedAdbLogArtifact ? { artifact: copiedAdbLogArtifact } : {}),
             },
         },
         environmentPreconditions: {
@@ -759,7 +973,7 @@ async function runProfileAndroid(args, options = {}) {
                 value: lifecyclePhase,
                 evidence: 'asserted',
                 source: environmentSource,
-                artifact: lifecycleArtifact,
+                ...(copiedAdbLogArtifact ? { artifact: copiedAdbLogArtifact } : {}),
             },
         },
         interactionDriver: agentDeviceCapture ? 'agent-device' : 'adb-logcat',

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

@@ -49,7 +49,7 @@ 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, commandId, config, queueId, runId, scenario, sequence, waitForMilestone, waitTimeoutMs, }: {
+declare function buildProfileSessionUrl({ action, command, commandId, config, queueId, runId, scenario, sequence, waitForMilestone, waitMs, waitTimeoutMs, }: {
     action: 'start' | 'command';
     command?: string;
     commandId?: string;
@@ -59,10 +59,11 @@ declare function buildProfileSessionUrl({ action, command, commandId, config, qu
     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}