agent-scenario-loop 0.1.3 → 0.1.5

package/app/profile-session.ts

@@ -21,6 +21,7 @@ export type ProfileSessionCommand = {
   source?: 'deeplink' | 'storage';
   timestamp: number;
   waitForMilestone?: string;
+  waitMs?: number;
   waitTimeoutMs?: number;
 };
 
@@ -67,6 +68,7 @@ type StoredProfileSessionEntry = {
   scenario: string;
   runId: string;
   timestamp: number;
+  atMs?: number;
   startedAt?: number;
   stoppedAt?: number;
   command?: string;
@@ -79,10 +81,22 @@ type StoredProfileSessionEntry = {
   source?: 'deeplink' | 'storage';
   status?: 'received' | 'queued' | 'delivered' | 'completed' | 'skipped';
   waitForMilestone?: string;
+  waitMs?: number;
   waitTimeoutMs?: number;
 };
 
 type StoredProfileSignals = Record<ProfileSignalKind, Record<string, unknown>>;
+type ProfileCommandMilestoneGate = {
+  commandId?: string;
+  id: string;
+  milestone: string;
+  queueId?: string;
+  runId?: string;
+  scenario?: string;
+  sequence?: number;
+  timeoutId?: ReturnType<typeof setTimeout>;
+  waitMs?: number;
+};
 
 const INITIAL_STATE: ProfileSessionState = {
   active: false,
@@ -111,9 +125,15 @@ const listeners = new Set<() => void>();
 const profileCommandListeners = new Set<(command: ProfileSessionCommand) => void>();
 const profileCommandTargetHandlers = new Map<string, () => void>();
 const pendingProfileCommands: ProfileSessionCommand[] = [];
+const sequencedProfileCommands: ProfileSessionCommand[] = [];
+const observedProfileEvents: StoredProfileEvent[] = [];
 const processedProfileCommandIds = new Set<string>();
 let lastProfileCommandSignature: string | null = null;
 let lastProfileCommandTimestamp = 0;
+let profileCommandMilestoneGate: ProfileCommandMilestoneGate | null = null;
+let profileCommandProcessingScheduled = false;
+let profileCommandProcessingTimeoutId: ReturnType<typeof setTimeout> | null = null;
+let profileCommandProcessingAvailableAt = 0;
 
 function writeProfileLog(line: string) {
   if (Platform.OS === 'ios') {
@@ -205,6 +225,7 @@ function appendStoredProfileEvent(event: StoredProfileEvent) {
 }
 
 function resetStoredProfileArtifacts() {
+  observedProfileEvents.length = 0;
   queueProfileStorageMutation(async () => {
     await Promise.all([
       AsyncStorage.removeItem(PROFILE_EVENT_STORAGE_KEY),
@@ -216,6 +237,9 @@ function resetStoredProfileArtifacts() {
 
 function clearPendingProfileCommands() {
   pendingProfileCommands.length = 0;
+  sequencedProfileCommands.length = 0;
+  clearProfileCommandMilestoneGate();
+  clearProfileCommandProcessingSchedule();
   queueProfileStorageMutation(async () => {
     await AsyncStorage.removeItem(PROFILE_COMMAND_STORAGE_KEY);
   });
@@ -299,7 +323,21 @@ export function isProfileSessionFresh(
 }
 
 function logProfileSession(kind: 'start' | 'stop' | 'command', payload: Record<string, unknown>) {
-  writeProfileLog(buildLogLine('profile-session', { kind, ...payload }));
+  const timestamp = Date.now();
+  const sessionStartedAt = readProfileSessionStartedAt(profileSessionState);
+  const atMs =
+    typeof payload.atMs === 'number' && Number.isFinite(payload.atMs)
+      ? payload.atMs
+      : sessionStartedAt !== null
+        ? Math.max(0, timestamp - sessionStartedAt)
+        : undefined;
+  const logPayload = {
+    kind,
+    ...payload,
+    timestamp,
+    ...(atMs !== undefined ? { atMs } : {}),
+  };
+  writeProfileLog(buildLogLine('profile-session', logPayload));
 
   const scenario = typeof payload.scenario === 'string' ? payload.scenario : null;
   const runId = typeof payload.runId === 'string' ? payload.runId : null;
@@ -307,12 +345,12 @@ function logProfileSession(kind: 'start' | 'stop' | 'command', payload: Record<s
     return;
   }
 
-  const timestamp = Date.now();
   const entry: StoredProfileSessionEntry = {
     kind,
     scenario,
     runId,
     timestamp,
+    ...(atMs !== undefined ? { atMs } : {}),
   };
 
   if (kind === 'start' && typeof payload.startedAt === 'number') {
@@ -362,6 +400,9 @@ function logProfileSession(kind: 'start' | 'stop' | 'command', payload: Record<s
     if (typeof payload.waitForMilestone === 'string') {
       entry.waitForMilestone = payload.waitForMilestone;
     }
+    if (typeof payload.waitMs === 'number') {
+      entry.waitMs = payload.waitMs;
+    }
     if (typeof payload.waitTimeoutMs === 'number') {
       entry.waitTimeoutMs = payload.waitTimeoutMs;
     }
@@ -379,6 +420,7 @@ function getProfileSessionRoute(url: string): {
   queueId?: string;
   sequence?: number;
   waitForMilestone?: string;
+  waitMs?: number;
   waitTimeoutMs?: number;
 } | null {
   const parsed = ExpoLinking.parse(url);
@@ -415,8 +457,12 @@ function getProfileSessionRoute(url: string): {
     typeof parsed.queryParams?.waitTimeoutMs === 'string' && Number.isInteger(Number(parsed.queryParams.waitTimeoutMs))
       ? Number(parsed.queryParams.waitTimeoutMs)
       : undefined;
+  const waitMs =
+    typeof parsed.queryParams?.waitMs === 'string' && Number.isInteger(Number(parsed.queryParams.waitMs))
+      ? Number(parsed.queryParams.waitMs)
+      : undefined;
 
-  return { action, scenario, runId, command, commandId, queueId, sequence, waitForMilestone, waitTimeoutMs };
+  return { action, scenario, runId, command, commandId, queueId, sequence, waitForMilestone, waitMs, waitTimeoutMs };
 }
 
 function queuePendingProfileCommand(command: ProfileSessionCommand) {
@@ -508,6 +554,132 @@ function markProfileCommandIdProcessed(command: ProfileSessionCommand) {
   }
 }
 
+function compareProfileCommands(left: ProfileSessionCommand, right: ProfileSessionCommand): number {
+  const leftSequence = typeof left.sequence === 'number' ? left.sequence : Number.POSITIVE_INFINITY;
+  const rightSequence = typeof right.sequence === 'number' ? right.sequence : Number.POSITIVE_INFINITY;
+  if (leftSequence !== rightSequence) {
+    return leftSequence - rightSequence;
+  }
+
+  return left.timestamp - right.timestamp;
+}
+
+function shouldQueueProfileCommand(command: ProfileSessionCommand): boolean {
+  return !hasProcessedProfileCommandId(command) &&
+    !sequencedProfileCommands.some((queuedCommand) => queuedCommand.id === command.id);
+}
+
+function buildProfileCommandMilestoneGate(command: ProfileSessionCommand): ProfileCommandMilestoneGate | null {
+  if (typeof command.waitForMilestone !== 'string' || command.waitForMilestone.length === 0) {
+    return null;
+  }
+
+  return {
+    id: command.id,
+    milestone: command.waitForMilestone,
+    ...(typeof command.commandId === 'string' ? { commandId: command.commandId } : {}),
+    ...(typeof command.queueId === 'string' ? { queueId: command.queueId } : {}),
+    ...(typeof command.runId === 'string' ? { runId: command.runId } : {}),
+    ...(typeof command.scenario === 'string' ? { scenario: command.scenario } : {}),
+    ...(typeof command.sequence === 'number' ? { sequence: command.sequence } : {}),
+    ...(typeof command.waitMs === 'number' && command.waitMs > 0 ? { waitMs: command.waitMs } : {}),
+  };
+}
+
+function hasObservedProfileCommandMilestone(command: ProfileSessionCommand): boolean {
+  if (typeof command.waitForMilestone !== 'string' || command.waitForMilestone.length === 0) {
+    return false;
+  }
+  if (typeof command.sequence === 'number' && command.sequence > 1) {
+    return false;
+  }
+
+  return observedProfileEvents.some((eventPayload) => (
+    eventPayload.event === command.waitForMilestone &&
+    (!command.runId || eventPayload.runId === command.runId) &&
+    (!command.scenario || eventPayload.scenario === command.scenario)
+  ));
+}
+
+function clearProfileCommandMilestoneGate() {
+  if (profileCommandMilestoneGate?.timeoutId) {
+    clearTimeout(profileCommandMilestoneGate.timeoutId);
+  }
+  profileCommandMilestoneGate = null;
+}
+
+function clearProfileCommandProcessingSchedule() {
+  if (profileCommandProcessingTimeoutId) {
+    clearTimeout(profileCommandProcessingTimeoutId);
+  }
+  profileCommandProcessingTimeoutId = null;
+  profileCommandProcessingScheduled = false;
+  profileCommandProcessingAvailableAt = 0;
+}
+
+function startProfileCommandMilestoneTimeout(command: ProfileSessionCommand) {
+  if (
+    !profileCommandMilestoneGate ||
+    typeof command.waitTimeoutMs !== 'number' ||
+    command.waitTimeoutMs <= 0
+  ) {
+    return;
+  }
+
+  profileCommandMilestoneGate.timeoutId = setTimeout(() => {
+    if (!profileCommandMilestoneGate || profileCommandMilestoneGate.id !== command.id) {
+      return;
+    }
+
+    logProfileSession('command', {
+      ...command,
+      status: 'skipped',
+      reason: 'wait-for-milestone-timeout',
+    });
+    clearProfileCommandMilestoneGate();
+    processSequencedProfileCommands();
+  }, command.waitTimeoutMs);
+}
+
+function scheduleProfileCommandProcessing(waitMs = 0) {
+  const availableAt = waitMs > 0 ? Date.now() + waitMs : 0;
+  if (availableAt > profileCommandProcessingAvailableAt) {
+    profileCommandProcessingAvailableAt = availableAt;
+  }
+
+  const delayMs = Math.max(0, profileCommandProcessingAvailableAt - Date.now());
+  if (profileCommandProcessingTimeoutId) {
+    clearTimeout(profileCommandProcessingTimeoutId);
+    profileCommandProcessingTimeoutId = null;
+  }
+
+  profileCommandProcessingScheduled = true;
+  const run = () => {
+    profileCommandProcessingTimeoutId = null;
+    const remainingMs = Math.max(0, profileCommandProcessingAvailableAt - Date.now());
+    if (remainingMs > 0) {
+      profileCommandProcessingScheduled = false;
+      scheduleProfileCommandProcessing(remainingMs);
+      return;
+    }
+    profileCommandProcessingAvailableAt = 0;
+    profileCommandProcessingScheduled = false;
+    processSequencedProfileCommands();
+  };
+
+  if (delayMs > 0) {
+    profileCommandProcessingTimeoutId = setTimeout(run, delayMs);
+    return;
+  }
+
+  if (typeof queueMicrotask === 'function') {
+    queueMicrotask(run);
+    return;
+  }
+
+  Promise.resolve().then(run);
+}
+
 function notifyProfileCommandListeners(command: ProfileSessionCommand) {
   const commandTimestamp = Number.isFinite(command.timestamp) ? command.timestamp : Date.now();
   if (shouldSkipProfileCommandForDuplicateWindow(command, commandTimestamp)) {
@@ -552,6 +724,82 @@ function notifyProfileCommandListeners(command: ProfileSessionCommand) {
   });
 }
 
+function processSequencedProfileCommands() {
+  if (profileCommandProcessingScheduled) {
+    return;
+  }
+  const remainingMs = Math.max(0, profileCommandProcessingAvailableAt - Date.now());
+  if (remainingMs > 0) {
+    scheduleProfileCommandProcessing(remainingMs);
+    return;
+  }
+  if (profileCommandMilestoneGate) {
+    return;
+  }
+
+  while (sequencedProfileCommands.length > 0) {
+    const command = sequencedProfileCommands.shift();
+    if (!command || hasProcessedProfileCommandId(command)) {
+      continue;
+    }
+
+    markProfileCommandIdProcessed(command);
+    const nextGate = hasObservedProfileCommandMilestone(command)
+      ? null
+      : buildProfileCommandMilestoneGate(command);
+    profileCommandMilestoneGate = nextGate;
+    logProfileSession('command', {
+      ...command,
+      status: 'received',
+    });
+    startProfileCommandMilestoneTimeout(command);
+    notifyProfileCommandListeners(command);
+
+    if (profileCommandMilestoneGate) {
+      return;
+    }
+    if (typeof command.waitMs === 'number' && command.waitMs > 0) {
+      scheduleProfileCommandProcessing(command.waitMs);
+      return;
+    }
+  }
+}
+
+function enqueueSequencedProfileCommands(commands: ProfileSessionCommand[]) {
+  const nextCommands = commands.filter(shouldQueueProfileCommand);
+  if (nextCommands.length === 0) {
+    return;
+  }
+
+  sequencedProfileCommands.push(...nextCommands);
+  sequencedProfileCommands.sort(compareProfileCommands);
+  processSequencedProfileCommands();
+}
+
+function releaseProfileCommandMilestoneGate(eventPayload: StoredProfileEvent) {
+  if (!profileCommandMilestoneGate || profileCommandMilestoneGate.milestone !== eventPayload.event) {
+    return;
+  }
+  if (
+    profileCommandMilestoneGate.runId &&
+    profileCommandMilestoneGate.runId !== eventPayload.runId
+  ) {
+    return;
+  }
+  if (
+    profileCommandMilestoneGate.scenario &&
+    profileCommandMilestoneGate.scenario !== eventPayload.scenario
+  ) {
+    return;
+  }
+
+  const waitMs = typeof profileCommandMilestoneGate.waitMs === 'number'
+    ? profileCommandMilestoneGate.waitMs
+    : 0;
+  clearProfileCommandMilestoneGate();
+  scheduleProfileCommandProcessing(waitMs);
+}
+
 function flushPendingProfileCommands(listener: (command: ProfileSessionCommand) => void) {
   if (pendingProfileCommands.length === 0) {
     return;
@@ -649,13 +897,10 @@ export function applyProfileSessionUrl(url: string | null | undefined): boolean
       source: 'deeplink' as const,
       timestamp,
       ...(route.waitForMilestone ? { waitForMilestone: route.waitForMilestone } : {}),
+      ...(typeof route.waitMs === 'number' ? { waitMs: route.waitMs } : {}),
       ...(typeof route.waitTimeoutMs === 'number' ? { waitTimeoutMs: route.waitTimeoutMs } : {}),
     };
-    logProfileSession('command', {
-      ...command,
-      status: 'received',
-    });
-    notifyProfileCommandListeners(command);
+    enqueueSequencedProfileCommands([command]);
     return true;
   }
 
@@ -698,7 +943,12 @@ export function emitProfileEvent(event: string, metadata?: ProfileEventMetadata)
   };
 
   writeProfileLog(buildLogLine('profile-event', eventPayload));
+  observedProfileEvents.push(eventPayload);
+  while (observedProfileEvents.length > MAX_STORED_PROFILE_EVENTS) {
+    observedProfileEvents.shift();
+  }
   appendStoredProfileEvent(eventPayload);
+  releaseProfileCommandMilestoneGate(eventPayload);
 }
 
 /**
@@ -838,7 +1088,7 @@ export function useProfileSessionBootstrap(): void {
         return;
       }
 
-      clearPendingProfileCommands();
+      const nextCommands: ProfileSessionCommand[] = [];
       for (const command of storedCommands) {
         if (
           !command ||
@@ -851,8 +1101,7 @@ export function useProfileSessionBootstrap(): void {
 
         if (
           command.scenario !== activeSession.scenario ||
-          command.runId !== activeSession.runId ||
-          (typeof activeSession.startedAt === 'number' && command.timestamp < activeSession.startedAt)
+          command.runId !== activeSession.runId
         ) {
           continue;
         }
@@ -866,13 +1115,10 @@ export function useProfileSessionBootstrap(): void {
           continue;
         }
 
-        markProfileCommandIdProcessed(storageCommand);
-        logProfileSession('command', {
-          ...storageCommand,
-          status: 'received',
-        });
-        notifyProfileCommandListeners(storageCommand);
+        nextCommands.push(storageCommand);
       }
+
+      enqueueSequencedProfileCommands(nextCommands);
     };
 
     syncStoredProfileState()

package/dist/core/artifact-contract.d.ts

@@ -56,10 +56,10 @@ declare function extractProfileSessionEntries(logText: string, filters?: {
 /**
  * Builds timing metrics from app-emitted profile events.
  *
- * @param {{scenario: string, runId: string, events: Record<string, unknown>[], expectedIterations: number, timeoutCount?: number, artifacts?: Record<string, unknown>, cycleEventNames?: Record<string, string> | null, budgets?: Record<string, unknown> | null}} options
+ * @param {{scenario: string, runId: string, events: Record<string, unknown>[], expectedIterations: number, timeoutCount?: number, artifacts?: Record<string, unknown>, cycleEventNames?: Record<string, string> | null, milestoneEventsPerIteration?: number, budgets?: Record<string, unknown> | null}} options
  * @returns {Record<string, unknown>}
  */
-declare function buildMetricsFromProfileEvents({ scenario, runId, events, expectedIterations, timeoutCount, artifacts, cycleEventNames, budgets, }: {
+declare function buildMetricsFromProfileEvents({ scenario, runId, events, expectedIterations, timeoutCount, artifacts, cycleEventNames, milestoneEventsPerIteration, budgets, }: {
     scenario: string;
     runId: string;
     events: ProfileEvent[];
@@ -67,17 +67,19 @@ declare function buildMetricsFromProfileEvents({ scenario, runId, events, expect
     timeoutCount?: number;
     artifacts?: ArtifactRecord;
     cycleEventNames?: ArtifactRecord | null;
+    milestoneEventsPerIteration?: number;
     budgets?: ArtifactRecord | null;
 }): ArtifactRecord;
 /**
  * Evaluates configured profile budgets against generated metrics.
  *
- * @param {{metrics: Record<string, unknown>, budgets?: Record<string, unknown> | null}} options
+ * @param {{metrics: Record<string, unknown>, budgets?: Record<string, unknown> | null, extraChecks?: BudgetCheck[]}} options
  * @returns {Record<string, unknown> | null}
  */
-declare function evaluateProfileBudgets({ metrics, budgets }: {
+declare function evaluateProfileBudgets({ metrics, budgets, extraChecks, }: {
     metrics: ArtifactRecord;
     budgets?: ArtifactRecord | null;
+    extraChecks?: BudgetCheck[];
 }): ArtifactRecord | null;
 /**
  * Recursively sorts object keys and array values for stable JSON artifacts.