agent-scenario-loop 0.1.2 → 0.1.4

package/dist/runner/profile-ios.js

@@ -28,12 +28,30 @@ const { runIosSimctlCapture } = require('./ios-simctl');
 const { runAgentDeviceCapture } = require('./agent-device');
 const { loadAslLocalEnv, readStringArgOrEnv } = require('./local-env');
 const PROFILE_SESSION_CAPTURE_BOOTSTRAP_MS = 1000;
-const PROFILE_SESSION_CAPTURE_MAX_MS = 30000;
+const PROFILE_SESSION_CAPTURE_COMMAND_OVERHEAD_MS = 250;
+const PROFILE_SESSION_CAPTURE_BUFFER_MIN_MS = 2000;
+const PROFILE_SESSION_CAPTURE_BUFFER_RATIO = 0.2;
+const PROFILE_SESSION_CAPTURE_MAX_MS = 10 * 60 * 1000;
 const DEFAULT_IOS_PROFILE_SESSION_STORAGE_KEY = 'agent-scenario-loop.profile-session.1';
 const DEFAULT_IOS_PROFILE_COMMAND_STORAGE_KEY = 'agent-scenario-loop.profile-commands.1';
 const DEFAULT_IOS_PROFILE_EVENT_STORAGE_KEY = 'agent-scenario-loop.profile-events.1';
 const DEFAULT_IOS_PROFILE_SIGNAL_STORAGE_KEY = 'agent-scenario-loop.profile-signals.1';
 const DEFAULT_IOS_PROFILE_SESSION_ENTRIES_STORAGE_KEY = 'agent-scenario-loop.profile-session-entries.1';
+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.
  *
@@ -63,6 +81,22 @@ function readPositiveInteger(value, fallback) {
     const parsed = typeof value === 'string' ? Number(value) : value;
     return typeof parsed === 'number' && Number.isInteger(parsed) && parsed > 0 ? parsed : 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.
  *
@@ -140,7 +174,7 @@ function resolveIosConflictingBundleIds(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'
@@ -149,6 +183,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()}`;
 }
@@ -169,24 +221,49 @@ function readStepWaitMs(step) {
     return readPositiveInteger(step.timeoutMs, 0);
 }
 /**
- * Derives a storage-backed profile capture window from scenario waits and cycles.
+ * Reads wait time from a profile-session command.
+ *
+ * @param {IosSimctlProfileCommand} command
+ * @returns {number}
+ */
+function readProfileCommandWindowMs(command) {
+    return readPositiveInteger(command.waitMs, 0) +
+        readPositiveInteger(command.waitTimeoutMs, 0) +
+        PROFILE_SESSION_CAPTURE_COMMAND_OVERHEAD_MS;
+}
+/**
+ * Reads execution-plan waits that are not already attached to a profile-session command.
  *
  * @param {Record<string, unknown>} scenario
  * @returns {number}
  */
-function deriveProfileSessionCaptureWaitMs(scenario) {
+function readUnattachedExecutionWaitMs(scenario) {
     const executionPlan = buildScenarioExecutionPlan(scenario);
     const iterations = readScenarioIterationCount(scenario);
-    const perIterationWaitMs = executionPlan.steps.reduce((total, step) => {
-        if (step.kind === 'command') {
-            return total + readStepWaitMs(step);
+    const perIterationWaitMs = executionPlan.steps.reduce((total, step, index) => {
+        if (step.portMethod !== 'waitForTruthEvent') {
+            return total;
         }
-        if (step.portMethod === 'waitForTruthEvent') {
-            return total + readPositiveInteger(step.timeoutMs, 0);
+        const previousStep = executionPlan.steps[index - 1];
+        if (previousStep?.portMethod === 'executeStep') {
+            return total;
         }
-        return total;
+        return total + readPositiveInteger(step.timeoutMs, 0);
     }, 0);
-    const derivedWaitMs = PROFILE_SESSION_CAPTURE_BOOTSTRAP_MS + (perIterationWaitMs * iterations);
+    return perIterationWaitMs * iterations;
+}
+/**
+ * Derives a storage-backed profile capture window from scenario waits, command gates, and cycles.
+ *
+ * @param {Record<string, unknown>} scenario
+ * @returns {number}
+ */
+function deriveProfileSessionCaptureWaitMs(scenario) {
+    const commands = resolveIosSimctlProfileCommands(scenario);
+    const commandWindowMs = commands.reduce((total, command) => total + readProfileCommandWindowMs(command), 0);
+    const executionWindowMs = commandWindowMs + readUnattachedExecutionWaitMs(scenario);
+    const bufferMs = Math.max(PROFILE_SESSION_CAPTURE_BUFFER_MIN_MS, Math.ceil(executionWindowMs * PROFILE_SESSION_CAPTURE_BUFFER_RATIO));
+    const derivedWaitMs = PROFILE_SESSION_CAPTURE_BOOTSTRAP_MS + executionWindowMs + bufferMs;
     return Math.min(Math.max(derivedWaitMs, PROFILE_SESSION_CAPTURE_BOOTSTRAP_MS), PROFILE_SESSION_CAPTURE_MAX_MS);
 }
 /**
@@ -211,14 +288,196 @@ function resolveProfileSessionCaptureWaitMs({ args, profileSessionEnabled, scena
 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 {IosSimctlProfileCommand} 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 {IosSimctlProfileCommand[]} 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 {IosSimctlProfileCommand[]} commands
+ * @param {number} repeat
+ * @returns {IosSimctlProfileCommand[]}
+ */
+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 {IosSimctlProfileCommand[]} commands
+ * @returns {IosSimctlProfileCommand[]}
+ */
+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 scenario-declared iOS commands for a simctl capture profile session.
@@ -240,12 +499,21 @@ function resolveIosSimctlProfileCommands(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);
 }
 /**
  * Returns true when the scenario asks iOS simctl capture to preserve a screenshot.
@@ -327,6 +595,7 @@ function appendAgentDeviceCaptureArgs({ args, capture, }) {
 async function runProfileIos(args, options = {}) {
     if (!isEnabled(args['simctl-capture']) && !isEnabled(args['agent-device-capture'])) {
         return runProfileMobile(args, {
+            commandTransport: typeof args.events === 'string' ? 'fixture-log-ingest' : 'simctl-artifacts',
             ...(options.comparisonLane ? { comparisonLane: options.comparisonLane } : {}),
             defaultDriver: 'ios-simctl',
             ...(typeof args['simctl-artifacts'] === 'string' ? { interactionDriver: 'ios-simctl' } : {}),
@@ -397,9 +666,15 @@ async function runProfileIos(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,
             })),
@@ -431,8 +706,14 @@ async function runProfileIos(args, options = {}) {
                     profileSessionStorage: {
                         commands: profileSessionCommands.map((profileCommand, index) => ({
                             command: profileCommand.command,
+                            ...(typeof profileCommand.commandId === 'string' ? { commandId: profileCommand.commandId } : {}),
                             id: `ios-storage-command-${index + 1}`,
                             ...(typeof profileCommand.label === 'string' ? { label: profileCommand.label } : {}),
+                            ...(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 } : {}),
                         })),
                         runId,
                         scenario: scenarioName,
@@ -496,9 +777,50 @@ async function runProfileIos(args, options = {}) {
     const profileArgs = agentDeviceCapture
         ? appendAgentDeviceCaptureArgs({ args: baseProfileArgs, capture: agentDeviceCapture })
         : baseProfileArgs;
+    const lifecyclePhase = resolveManifestLifecyclePhase(args);
+    const environmentSource = agentDeviceCapture ? 'agent-device' : 'simctl';
+    const copiedSimctlLogArtifact = simctlCapture &&
+        !fs.existsSync(path.join(simctlCapture.runDir, 'raw', 'ios-profile-events.log')) &&
+        fs.existsSync(path.join(simctlCapture.runDir, 'raw', 'ios-simctl-log.txt'))
+        ? 'raw/ios-simctl-log.txt'
+        : undefined;
     return runProfileMobile(profileArgs, {
+        commandTransport: agentDeviceCapture
+            ? 'agent-device'
+            : profileSessionEnabled && !profileSessionStorageEnabled
+                ? 'profile-session-deeplink'
+                : profileSessionEnabled
+                    ? 'profile-session-storage'
+                    : 'simctl-capture',
         ...(options.comparisonLane ? { comparisonLane: options.comparisonLane } : {}),
         defaultDriver: 'ios-simctl',
+        environmentPostconditions: {
+            appState: {
+                value: 'foreground',
+                evidence: 'asserted',
+                source: environmentSource,
+                ...(copiedSimctlLogArtifact ? { artifact: copiedSimctlLogArtifact } : {}),
+            },
+            lifecyclePhase: {
+                value: 'foreground',
+                evidence: 'asserted',
+                source: environmentSource,
+                ...(copiedSimctlLogArtifact ? { artifact: copiedSimctlLogArtifact } : {}),
+            },
+        },
+        environmentPreconditions: {
+            foregroundState: {
+                value: 'controlled-by-runner',
+                evidence: 'asserted',
+                source: environmentSource,
+            },
+            lifecyclePhase: {
+                value: lifecyclePhase,
+                evidence: 'asserted',
+                source: environmentSource,
+                ...(copiedSimctlLogArtifact ? { artifact: copiedSimctlLogArtifact } : {}),
+            },
+        },
         interactionDriver: agentDeviceCapture ? 'agent-device' : 'ios-simctl',
         platform: 'ios',
     });

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

@@ -21,31 +21,61 @@ type ProfileRunResult = {
 };
 type ProfilePlatform = 'android' | 'ios';
 type ProfileMobileOptions = {
+    commandTransport?: string;
     comparisonLane?: string;
     defaultDriver: string;
+    environmentPostconditions?: Record<string, unknown>;
+    environmentPreconditions?: Record<string, unknown>;
     interactionDriver?: string;
     platform: ProfilePlatform;
+    provenanceCohort?: Record<string, unknown>;
 };
 type CaptureEvidenceKind = 'screenshot' | 'uiTree' | 'video';
 type ProviderEvidenceKind = 'accessibility' | 'logs' | 'profiler';
 type SignalEvidenceKind = 'js' | 'memory' | 'network';
 type EvidenceChannel = 'capture' | 'provider' | 'signal';
 type EvidenceKind = CaptureEvidenceKind | ProviderEvidenceKind | SignalEvidenceKind;
+type DiagnosticStatus = 'captured' | 'not_requested' | 'not_supported' | 'unavailable' | 'failed' | 'skipped' | 'missing';
+type DiagnosticKind = EvidenceKind | 'logs';
+type DiagnosticInventoryEntry = {
+    kind: DiagnosticKind;
+    status: DiagnosticStatus;
+    required: boolean;
+    name?: string;
+    provider?: string;
+    runnerId?: string;
+    path?: string;
+    reason?: string;
+    nextAction?: string;
+    sidecarRoot?: string;
+    evidenceDependency?: {
+        kind: string;
+        root?: 'run' | 'sidecar';
+        path: string;
+    };
+};
 type EvidenceAttachment = {
     channel: EvidenceChannel;
+    completenessStatus: 'complete';
+    corruptionStatus: 'valid';
     destinationPath: string;
     kind: EvidenceKind;
     manifestPath: string;
+    redactionStatus: 'not-redacted';
+    required: boolean;
     sha256: string;
     sourcePath: string;
     sourceFileName: string;
     sizeBytes: number;
+    transformations: readonly ['copied'];
 };
 type EvidenceAttachmentInput = {
     channel: EvidenceChannel;
     destinationPath: string;
     kind: EvidenceKind;
     manifestPath: string;
+    providerId?: string;
+    required?: boolean;
     sourcePath: string;
 };
 type AttachedEvidence = {
@@ -62,6 +92,7 @@ type ProviderCommandOutput = {
     channel: EvidenceChannel;
     kind: EvidenceKind;
     path: string;
+    required?: boolean;
 };
 type ProviderCommand = {
     args?: string[];
@@ -70,7 +101,7 @@ type ProviderCommand = {
     env?: Record<string, string>;
     id: string;
     outputs: ProviderCommandOutput[];
-    phase: 'prepare' | 'startWindow' | 'capture' | 'stopWindow' | 'finalize';
+    phase: 'prepare' | 'startWindow' | 'capture' | 'stopWindow' | 'afterCapture' | 'postRun' | 'finalize';
 };
 type ProviderCommandFailure = {
     commandId: string;
@@ -131,13 +162,18 @@ declare function resolveAttachedEvidence({ args, layout, providerInputs, }: {
 /**
  * Builds scenario health from profile metrics.
  *
- * @param {{scenario: Record<string, unknown>, runId: string, metrics: Record<string, unknown>}} options
+ * @param {{scenario: Record<string, unknown>, runId: string, metrics: Record<string, unknown>, diagnostics?: DiagnosticInventoryEntry[], profileEventCount?: number, profileSessionEntryCount?: number, commandTransport?: string, sessionEntries?: Record<string, unknown>[]}} options
  * @returns {Record<string, unknown>}
  */
-declare function buildProfileHealth({ scenario, runId, metrics, }: {
+declare function buildProfileHealth({ scenario, runId, metrics, diagnostics, profileEventCount, profileSessionEntryCount, commandTransport, sessionEntries, }: {
     scenario: Record<string, any>;
     runId: string;
     metrics: Record<string, any>;
+    diagnostics?: DiagnosticInventoryEntry[];
+    profileEventCount?: number;
+    profileSessionEntryCount?: number;
+    commandTransport?: string;
+    sessionEntries?: Record<string, any>[];
 }): Record<string, unknown>;
 /**
  * Builds failed scenario health from evidence-provider command failures.