agent-scenario-loop 0.1.2 → 0.1.3

package/dist/runner/profile-mobile.js

@@ -26,7 +26,7 @@ const crypto = require('node:crypto');
 const { buildAgentSummaryMarkdown } = require('../core/agent-summary');
 const { createArtifactLayout } = require('../core/artifact-layout');
 const { writeJsonArtifact, writeTextArtifact } = require('../core/artifact-writer');
-const { buildBudgetVerdict, buildCausalRun, buildCausalTimeline, buildManifest, buildMetricsFromProfileEvents, buildSummaryMarkdown, extractProfileEvents, } = require('../core/artifact-contract');
+const { buildBudgetVerdict, buildCausalRun, buildCausalTimeline, buildManifest, buildMetricsFromProfileEvents, buildSummaryMarkdown, extractProfileEvents, extractProfileSessionEntries, } = require('../core/artifact-contract');
 const { SCHEMAS, assertValidJson } = require('../core/schema-validator');
 const { writeUsage } = require('./cli');
 const CAPTURE_EVIDENCE_KINDS = new Set(['screenshot', 'uiTree', 'video']);
@@ -62,6 +62,7 @@ function usage({ binaryName, output = process.stderr, platform, }) {
     }
     lines.push('Use --agent-device-capture to execute scenario-declared portable driver actions through agent-device and attach its captures.');
     lines.push('Use --agent-device-session-mode bind when a named agent-device session should still receive the configured Android serial or iOS UDID.');
+    lines.push('Use --lifecycle-phase <phase> when the runner can explicitly assert a non-cold lifecycle precondition such as warm-launch or resume.');
     writeUsage(lines, output);
 }
 /**
@@ -300,9 +301,10 @@ function assertUniqueProviderCommandIds({ providerCommands = [], providerId, })
 async function executeProviderCommands({ args, layout, platform, runDir, runId, scenarioId, }) {
     const failures = [];
     const inputs = [];
+    const providers = [];
     const providerManifestPaths = readRepeatableArgValues(args, 'provider');
     if (providerManifestPaths.length === 0) {
-        return { failures, inputs };
+        return { failures, inputs, providers };
     }
     const commandRecordDir = path.join(layout.raw, 'provider-commands');
     await ensureDir(commandRecordDir);
@@ -314,6 +316,10 @@ async function executeProviderCommands({ args, layout, platform, runDir, runId,
             throw new Error(`Provider manifest must use kind "evidenceProvider": ${absoluteManifestPath}`);
         }
         const providerId = safeProviderSegment(String(provider.runnerId ?? path.basename(absoluteManifestPath, '.json')));
+        providers.push({
+            name: providerId,
+            ...(typeof provider.version === 'string' ? { version: provider.version } : {}),
+        });
         if (Array.isArray(provider.platforms) && !provider.platforms.includes(platform)) {
             failures.push({
                 commandId: 'platform-compatibility',
@@ -392,7 +398,7 @@ async function executeProviderCommands({ args, layout, platform, runDir, runId,
             }
         }
     }
-    return { failures, inputs };
+    return { failures, inputs, providers };
 }
 /**
  * Converts internal attachment copy plans into manifest-safe metadata.
@@ -403,11 +409,15 @@ async function executeProviderCommands({ args, layout, platform, runDir, runId,
 function buildEvidenceAttachmentManifest(attachments) {
     return attachments.map((attachment) => ({
         channel: attachment.channel,
+        completenessStatus: attachment.completenessStatus,
+        corruptionStatus: attachment.corruptionStatus,
         kind: attachment.kind,
         path: attachment.manifestPath,
+        redactionStatus: attachment.redactionStatus,
         sha256: attachment.sha256,
         sizeBytes: attachment.sizeBytes,
         sourceFileName: attachment.sourceFileName,
+        transformations: attachment.transformations,
     }));
 }
 /**
@@ -443,13 +453,17 @@ async function resolveAttachedEvidence({ args, layout, providerInputs = [], }) {
         destinationPaths.add(destinationPath);
         const attachment = {
             channel,
+            completenessStatus: 'complete',
+            corruptionStatus: 'valid',
             destinationPath,
             kind,
             manifestPath,
+            redactionStatus: 'not-redacted',
             sha256: await hashFileSha256(sourcePath),
             sourceFileName: path.basename(sourcePath),
             sourcePath,
             sizeBytes: stat.size,
+            transformations: ['copied'],
         };
         attached.attachments.push(attachment);
         attached.copies.push(attachment);
@@ -595,6 +609,76 @@ function buildProfileHealth({ scenario, runId, metrics, }) {
         ],
     }, SCHEMAS.health, 'Health artifact');
 }
+/**
+ * Derives the terminal state for one profile artifact attempt.
+ *
+ * @param {Record<string, unknown>} metrics
+ * @returns {string}
+ */
+function buildAttemptTerminalState(metrics) {
+    if (metrics.status === 'passed') {
+        return 'passed';
+    }
+    if (typeof metrics.timeouts === 'number' && metrics.timeouts > 0) {
+        return 'timeout';
+    }
+    return 'failed';
+}
+/**
+ * Classifies one profile artifact attempt without product-specific vocabulary.
+ *
+ * @param {Record<string, unknown>} metrics
+ * @returns {Record<string, unknown>}
+ */
+function buildAttemptClassification(metrics) {
+    if (metrics.status === 'passed') {
+        return {
+            category: 'none',
+        };
+    }
+    if (typeof metrics.timeouts === 'number' && metrics.timeouts > 0) {
+        return {
+            category: 'timeout',
+            code: 'profile_truth_event_timeout',
+            message: `Profile run recorded ${metrics.timeouts} timeout(s) before all expected truth events completed.`,
+            retryable: true,
+        };
+    }
+    return {
+        category: 'evidence',
+        code: 'profile_truth_events_incomplete',
+        message: 'Profile run did not capture every expected truth event.',
+        retryable: true,
+    };
+}
+/**
+ * Records whether the written artifact set is valid for diagnosis when a run fails.
+ *
+ * @param {{artifacts: Record<string, unknown>, metrics: Record<string, unknown>}} options
+ * @returns {Record<string, unknown>}
+ */
+function buildAttemptPartialArtifacts({ artifacts, metrics, }) {
+    if (metrics.status === 'passed') {
+        return {
+            valid: false,
+            reason: 'complete successful run artifacts are present',
+        };
+    }
+    const paths = [
+        artifacts.manifest,
+        'health.json',
+        artifacts.metrics,
+        artifacts.causalRun,
+        artifacts.summary,
+        artifacts.raw?.interactionLog,
+        artifacts.raw?.deviceLog,
+    ].filter((item) => typeof item === 'string' && item.length > 0);
+    return {
+        valid: true,
+        reason: 'failed profile run artifacts are preserved for diagnosis and are not a product proof until scenario health passes',
+        paths,
+    };
+}
 /**
  * Builds failed scenario health from evidence-provider command failures.
  *
@@ -760,6 +844,19 @@ function resolveEventLogPath({ args, platform }) {
     }
     return null;
 }
+/**
+ * Resolves the optional profile-session entry artifact path for command acknowledgement evidence.
+ *
+ * @param {{args: CliArgs, platform: ProfilePlatform}} options
+ * @returns {string | null}
+ */
+function resolveProfileSessionEntriesPath({ args, platform }) {
+    if (platform === 'ios' && typeof args['simctl-artifacts'] === 'string') {
+        const storedEntriesPath = path.resolve(args['simctl-artifacts'], 'raw', 'ios-profile-session-entries.json');
+        return fs.existsSync(storedEntriesPath) ? storedEntriesPath : null;
+    }
+    return null;
+}
 /**
  * Reads a JSON artifact if it exists and contains an object.
  *
@@ -1071,6 +1168,105 @@ function resolveProfileBudgets(scenario) {
         }
         : null;
 }
+/**
+ * Reads the installed package version for run provenance.
+ *
+ * @returns {string}
+ */
+function readAslPackageVersion() {
+    try {
+        const packageJsonPath = path.resolve(__dirname, '..', '..', 'package.json');
+        const packageJson = readJson(packageJsonPath);
+        return typeof packageJson.version === 'string' ? packageJson.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Infers the command transport used for profile-session or fixture evidence.
+ *
+ * @param {{args: CliArgs, interactionDriver: string, options: ProfileMobileOptions}} options
+ * @returns {string}
+ */
+function resolveCommandTransport({ args, interactionDriver, options, }) {
+    if (typeof options.commandTransport === 'string' && options.commandTransport.length > 0) {
+        return options.commandTransport;
+    }
+    if (typeof args.events === 'string') {
+        return 'fixture-log-ingest';
+    }
+    if (typeof args['ios-profile-session-transport'] === 'string') {
+        return `profile-session-${args['ios-profile-session-transport']}`;
+    }
+    if (args['android-profile-session-storage'] || args['ios-profile-session-storage']) {
+        return 'profile-session-storage';
+    }
+    if (args['profile-session']) {
+        return 'profile-session-deeplink';
+    }
+    if (typeof args['adb-artifacts'] === 'string') {
+        return 'adb-artifacts';
+    }
+    if (typeof args['simctl-artifacts'] === 'string') {
+        return 'simctl-artifacts';
+    }
+    return interactionDriver;
+}
+/**
+ * Builds product-neutral provenance cohort metadata for the run manifest.
+ *
+ * @param {{args: CliArgs, appId: string, interactionDriver: string, options: ProfileMobileOptions, providerExecution: ProviderCommandExecution}} options
+ * @returns {Record<string, unknown>}
+ */
+function buildProfileProvenanceCohort({ appId, args, interactionDriver, options, providerExecution, }) {
+    return {
+        appId,
+        commandTransport: resolveCommandTransport({ args, interactionDriver, options }),
+        platform: options.platform,
+        providers: providerExecution.providers,
+        runnerName: interactionDriver,
+        runnerVersion: readAslPackageVersion(),
+        ...options.provenanceCohort,
+    };
+}
+/**
+ * Builds an environment assertion for manifest pre/postconditions.
+ *
+ * @param {{artifact?: string, evidence?: string, source: string, value: unknown}} options
+ * @returns {Record<string, unknown>}
+ */
+function environmentAssertion({ artifact, evidence = 'asserted', source, value, }) {
+    return {
+        value,
+        evidence,
+        source,
+        ...(artifact ? { artifact } : {}),
+    };
+}
+/**
+ * Builds postconditions that ASL can truthfully assert after writing profile artifacts.
+ *
+ * @param {{metrics: Record<string, unknown>, options: ProfileMobileOptions}} options
+ * @returns {Record<string, unknown>}
+ */
+function buildProfileEnvironmentPostconditions({ metrics, options, }) {
+    const runPassed = metrics.status === 'passed';
+    return {
+        artifactState: environmentAssertion({
+            value: runPassed ? 'complete' : 'partial',
+            evidence: 'asserted',
+            source: 'asl-profile-runner',
+            artifact: 'manifest.json',
+        }),
+        cleanupState: environmentAssertion({
+            value: 'not-required',
+            evidence: 'asserted',
+            source: 'asl-profile-runner',
+        }),
+        ...options.environmentPostconditions,
+    };
+}
 /**
  * Runs the mobile log-ingest profile artifact pipeline.
  *
@@ -1100,6 +1296,7 @@ async function runProfileMobile(args, options) {
     const capturesDir = layout.captures;
     const startedAt = new Date().toISOString();
     const eventLogPath = resolveEventLogPath({ args, platform: options.platform });
+    const profileSessionEntriesPath = resolveProfileSessionEntriesPath({ args, platform: options.platform });
     const interactionDriver = resolveInteractionDriver({ config, options, scenario });
     const comparisonLane = resolveComparisonLane({ args, options, scenario });
     await ensureDir(rawDir);
@@ -1151,6 +1348,26 @@ async function runProfileMobile(args, options) {
         scenario: scenarioName,
         runId,
     });
+    const logSessionEntries = extractProfileSessionEntries(eventLogText, {
+        scenario: scenarioName,
+        runId,
+    });
+    const storedSessionEntries = profileSessionEntriesPath
+        ? JSON.parse(await fsp.readFile(profileSessionEntriesPath, 'utf8'))
+        : [];
+    const sessionEntries = [
+        ...logSessionEntries,
+        ...(Array.isArray(storedSessionEntries)
+            ? storedSessionEntries.filter((entry) => {
+                if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                    return false;
+                }
+                const record = entry;
+                return ((!('scenario' in record) || record.scenario === scenarioName) &&
+                    (!('runId' in record) || record.runId === runId));
+            })
+            : []),
+    ];
     const runtimeTarget = resolveRuntimeTarget({ args, platform: options.platform });
     const metrics = buildMetricsFromProfileEvents({
         scenario: scenarioName,
@@ -1164,48 +1381,67 @@ async function runProfileMobile(args, options) {
             signals: attachedEvidence.signals,
         },
     });
+    const manifestArtifacts = {
+        causalRun: 'causal-run.json',
+        budgetVerdict: 'budget-verdict.json',
+        manifest: 'manifest.json',
+        metrics: 'metrics.json',
+        summary: 'summary.md',
+        scenario: toPortablePathReference(scenarioPath),
+        raw: {
+            interactionLog: eventLogPath ? `raw/${path.basename(eventLogPath)}` : 'raw/interaction.log',
+            deviceLog: 'raw/device.log',
+        },
+        captures: {
+            screenshots: attachedEvidence.captures.screenshots,
+            video: attachedEvidence.captures.video ?? 'captures/run.mp4',
+            uiTree: attachedEvidence.captures.uiTree ?? 'captures/ui-tree.json',
+        },
+        signals: {
+            js: attachedEvidence.signals.js,
+            memory: attachedEvidence.signals.memory,
+            network: attachedEvidence.signals.network,
+        },
+        evidenceAttachments: buildEvidenceAttachmentManifest(attachedEvidence.attachments),
+    };
+    const appId = resolveAppId({ config, platform: options.platform });
+    const provenanceCohort = buildProfileProvenanceCohort({
+        appId,
+        args,
+        interactionDriver,
+        options,
+        providerExecution,
+    });
     const manifest = buildManifest({
         scenario: scenarioName,
         scenarioHash,
         runId,
         platform: options.platform,
         status: metrics.status,
+        terminalState: buildAttemptTerminalState(metrics),
         endedAt: new Date().toISOString(),
         interactionDriver,
         comparisonLane,
+        classification: buildAttemptClassification(metrics),
+        cleanup: {
+            status: 'not-required',
+        },
+        partialArtifacts: buildAttemptPartialArtifacts({ artifacts: manifestArtifacts, metrics }),
+        preconditions: options.environmentPreconditions,
+        postconditions: buildProfileEnvironmentPostconditions({ metrics, options }),
         startedAt,
         simulator: runtimeTarget,
-        bundleId: resolveAppId({ config, platform: options.platform }),
+        bundleId: appId,
         gitSha: 'unknown',
         toolVersions: {
             node: process.version,
         },
-        artifacts: {
-            causalRun: 'causal-run.json',
-            budgetVerdict: 'budget-verdict.json',
-            manifest: 'manifest.json',
-            metrics: 'metrics.json',
-            summary: 'summary.md',
-            scenario: toPortablePathReference(scenarioPath),
-            raw: {
-                interactionLog: eventLogPath ? `raw/${path.basename(eventLogPath)}` : 'raw/interaction.log',
-                deviceLog: 'raw/device.log',
-            },
-            captures: {
-                screenshots: attachedEvidence.captures.screenshots,
-                video: attachedEvidence.captures.video ?? 'captures/run.mp4',
-                uiTree: attachedEvidence.captures.uiTree ?? 'captures/ui-tree.json',
-            },
-            signals: {
-                js: attachedEvidence.signals.js,
-                memory: attachedEvidence.signals.memory,
-                network: attachedEvidence.signals.network,
-            },
-            evidenceAttachments: buildEvidenceAttachmentManifest(attachedEvidence.attachments),
-        },
+        cohort: provenanceCohort,
+        artifacts: manifestArtifacts,
     });
     const timeline = buildCausalTimeline({
         events,
+        sessionEntries,
         startedAt,
         phaseMap: scenario.timelinePhases ?? null,
         owner: scenario.flowId ?? scenarioName,
@@ -1231,7 +1467,7 @@ async function runProfileMobile(args, options) {
     });
     const health = buildProfileHealth({ scenario: profileScenario, runId, metrics });
     const verdict = buildProfileVerdict({ scenario: profileScenario, runId, health, metrics });
-    const agentSummary = buildAgentSummaryMarkdown({ health, verdict });
+    const agentSummary = buildAgentSummaryMarkdown({ health, verdict, manifest });
     const summary = buildSummaryMarkdown({ manifest, metrics });
     await writeJsonArtifact({
         filePath: layout.health,
@@ -1282,6 +1518,9 @@ async function runProfileMobile(args, options) {
     if (eventLogPath) {
         await fsp.copyFile(eventLogPath, path.join(rawDir, path.basename(eventLogPath)));
     }
+    if (profileSessionEntriesPath) {
+        await fsp.copyFile(profileSessionEntriesPath, path.join(rawDir, path.basename(profileSessionEntriesPath)));
+    }
     await copyAttachedEvidence(attachedEvidence.copies);
     return {
         runDir,

package/docs/adapters.md

@@ -143,3 +143,7 @@ If the provider should run during profiling, declare `providerCommands` in its m
 - Passed runs write the standard artifact set.
 - Attached evidence is inventoried with stable run-relative paths.
 - Package docs describe whether the adapter is bundled, a fixture target, or a project-local integration.
+
+## Read next
+
+- [Consumer App Rehearsal](consumer-rehearsal.md) for adopting the package inside an existing app

package/docs/architecture.md

@@ -0,0 +1,90 @@
+# Architecture
+
+ASL is implemented in TypeScript, but its contracts are language-neutral.
+
+The TypeScript package is the reference implementation for planning, execution,
+schema validation, artifact writing, health/verdict/comparison interpretation,
+run indexing, CLIs, the TypeScript runner SDK, and the React Native/Expo helper.
+Those implementation modules are not the interoperability contract.
+
+## Contract Boundary
+
+JSON Schema and normative documentation are the source of truth for external
+participants. TypeScript interfaces should reflect those contracts, not replace
+them.
+
+Language-neutral contracts include:
+
+- scenario schemas;
+- runner and evidence-provider manifests;
+- capability definitions;
+- truth-event envelopes;
+- command and result envelopes;
+- lifecycle states;
+- error taxonomy;
+- artifact schemas;
+- cancellation and timeout semantics;
+- protocol-version negotiation.
+
+External adapters must be able to participate out of process. A valid adapter
+may be an executable written in Swift, Kotlin, Python, Rust, shell, TypeScript,
+or another language, provided it satisfies the documented schemas and protocol.
+The minimal executable protocol is described in
+[External Adapter Protocol](external-adapter-protocol.md).
+
+## Reference Environments
+
+React Native and Expo remain the primary active battle-testing environment.
+They provide real Android and iOS pressure across lifecycle behavior, command
+transport, native boundaries, instrumentation, packaging, evidence provenance,
+and agent-facing summaries.
+
+The React Native helper is a reference transport. It does not define the truth
+event contract by itself. Native apps must be able to emit ASL truth events
+without embedding a JavaScript runtime.
+
+## Public Interoperability Rules
+
+- Scenario files must remain structured data, not arbitrary JavaScript.
+- Runners and providers must not be required to subclass TypeScript classes.
+- Large evidence should be passed by file reference, not embedded as base64.
+- External adapters should use structured protocol messages over stdio.
+- Messages should carry run ids, attempt ids, sequence numbers, operation ids,
+  deadlines, platform, clock-domain metadata, adapter identity, and artifact
+  references where applicable.
+- Failed operations should return structured failure data with stable codes,
+  classes, retryability, and next-action hints.
+
+## Audit Snapshot
+
+Current public contracts are JSON schemas and JSON manifests. Scenario fixtures
+are structured JSON and do not require callbacks or closures. Runner/provider
+manifests describe capabilities and commands as data.
+
+Known implementation-specific surfaces are intentionally reference paths:
+
+- npm package scripts and Node CLIs are the TypeScript distribution channel.
+- built-in adb, simctl, Argent, and agent-device runners are TypeScript
+  adapters.
+- React Native profile-session logging and AsyncStorage are reference truth
+  event transports.
+- provider command examples use Node scripts, but provider manifests can point
+  at any executable.
+
+These are acceptable as reference implementation details. They should not become
+requirements in scenario schemas, artifact schemas, or external-adapter protocol
+messages.
+
+## Future Design Test
+
+Could a Swift, Kotlin, Python, or Rust implementation satisfy this contract
+using only the schemas, protocol documentation, executable interface, and
+conformance fixtures?
+
+If yes, TypeScript remains a productive reference implementation. If no, the
+implementation-specific assumption should be identified and removed from the
+contract surface.
+
+## Read next
+
+- [External Adapter Protocol](external-adapter-protocol.md) for the out-of-process adapter envelope, operations, failures, and conformance fixture

package/docs/authoring.md

@@ -159,7 +159,7 @@ asl-profile-android \
   --capture uiTree:artifacts/provider/ui-tree.json
 ```
 
-Signals are copied into `signals/js`, `signals/memory`, or `signals/network` and listed in `manifest.json`. Captures are copied into `captures`; screenshots are listed in `artifacts.captures.screenshots`, while video and UI tree captures replace the matching named capture path in the manifest. Every attached file is also listed in `artifacts.evidenceAttachments` with kind, run-relative path, source filename, byte size, and sha256 hash. Attached provider evidence is preserved as proof, but timing verdicts still come from app-owned truth events and budgets.
+Signals are copied into `signals/js`, `signals/memory`, or `signals/network` and listed in `manifest.json`. Captures are copied into `captures`; screenshots are listed in `artifacts.captures.screenshots`, while video and UI tree captures replace the matching named capture path in the manifest. Every attached file is also listed in `artifacts.evidenceAttachments` with kind, run-relative path, source filename, byte size, sha256 hash, completeness status, corruption status, redaction status, and transformation list. Attached provider evidence is preserved as proof, but timing verdicts still come from app-owned truth events and budgets.
 
 Provider manifests can also declare `providerCommands`. Profile runners execute those commands when passed with `--provider <manifest>`, but only when the provider manifest includes the selected platform. A provider with `platforms: ["ios"]` passed to an Android profile writes failed `health.json` with `provider_platform_unsupported` and does not run the command. Commands run without a shell, can use placeholders such as `{providerDir}`, `{runDir}`, `{runId}`, `{scenarioId}`, and `{platform}`, and must declare their output files. Provider-channel outputs are copied or preserved under `raw/providers/<provider-id>/` and inventoried in `artifacts.evidenceAttachments`; signal and capture outputs can still map into the standard `signals/*` or `captures/` folders. Command stdout, stderr, exit code, phase, and argv are preserved under `raw/provider-commands/`. When a provider command exits nonzero, the runner writes failed `health.json`, inconclusive `verdict.json`, and `agent-summary.md` with a next-action hint instead of making timing claims.
 
@@ -196,3 +196,7 @@ Run the release gate before publishing package changes:
 ```bash
 pnpm release:check
 ```
+
+## Read next
+
+- [Adapter Onboarding](adapters.md) for runner and provider integration

package/docs/concepts.md

@@ -104,33 +104,12 @@ The tooling may change. The runners may change. The agents may change. The scena
 
 That is a different philosophy from frameworks that primarily evaluate agents. Agent Scenario Loop is built to evaluate the evolution of software.
 
-## How it differs from testing frameworks
+## Boundary
 
-Agent Scenario Loop does not make existing testing frameworks obsolete.
+Agent Scenario Loop is not a replacement for testing frameworks, automation tools, mobile drivers, profilers, or agent evaluation systems. Those tools can still execute or observe work.
 
-Traditional frameworks usually optimize for:
-
-> Did the application behave correctly?
-
-Agent Scenario Loop optimizes for:
-
-> What did we learn from running this scenario?
-
-Both questions matter. Agent Scenario Loop focuses on the second question by preserving health, verdicts, metrics, logs, traces, comparisons, and other run evidence in a stable artifact shape.
-
-## How it differs from agent evaluation
-
-Agent Scenario Loop is not primarily evaluating agents.
-
-An agent may execute part of a run. A runner may drive a device. A profiler may collect signals. None of those is the center of the model.
-
-The scenario is.
-
-The feed, livestream, upload flow, checkout flow, or conversation thread is the thing being studied over time.
+The canonical boundary list lives in [What It Is Not](../README.md#what-it-is-not).
 
 ## Read next
 
 - [Principles](principles.md) for the project doctrine
-- [Contracts](contracts.md) for the current artifact and package surface
-- [Live Proofs](live-proofs.md) for fixture, Android, iOS, and comparison runs
-- [Runner docs](../runner/README.md) for the host execution boundary

package/docs/consumer-rehearsal.md

@@ -113,3 +113,7 @@ Before expanding beyond the first journey, confirm:
 - at least one platform has a passed live proof
 
 Only then add more scenarios, providers, or runner adapters.
+
+## Read next
+
+- [Live Proofs](live-proofs.md) for fixture, Android, iOS, comparison, and release-proof commands