agent-scenario-loop 0.1.3 → 0.1.4

package/dist/scripts/consumer-rehearsal.js

@@ -0,0 +1,757 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRehearsalEnv = createRehearsalEnv;
+exports.mergeGeneratedScripts = mergeGeneratedScripts;
+exports.packageBinPath = packageBinPath;
+exports.packPackage = packPackage;
+exports.readJson = readJson;
+exports.rehearseConsumerInstall = rehearseConsumerInstall;
+exports.replaceConfigPlaceholders = replaceConfigPlaceholders;
+exports.run = run;
+exports.runExpectFailure = runExpectFailure;
+exports.writeFakeArgent = writeFakeArgent;
+exports.writeExistingAppFixture = writeExistingAppFixture;
+exports.writeProfileEventFixtures = writeProfileEventFixtures;
+exports.writeJson = writeJson;
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const DEFAULT_COMMAND_TIMEOUT_MS = 180_000;
+/**
+ * Creates a clean npm environment for local tarball install rehearsals.
+ *
+ * @param {string} tempRoot
+ * @returns {NodeJS.ProcessEnv}
+ */
+function createRehearsalEnv(tempRoot) {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+        if (key.toLowerCase().startsWith('npm_config_')) {
+            delete env[key];
+        }
+    }
+    env.npm_config_audit = 'false';
+    env.npm_config_cache = path.join(tempRoot, 'npm-cache');
+    env.npm_config_fund = 'false';
+    env.npm_config_update_notifier = 'false';
+    return env;
+}
+/**
+ * Resolves the per-command timeout for package gate child processes.
+ *
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {number}
+ */
+function resolveCommandTimeoutMs(env) {
+    const timeoutMs = Number.parseInt(env.ASL_PACKAGE_GATE_TIMEOUT_MS ?? '', 10);
+    return Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? timeoutMs
+        : DEFAULT_COMMAND_TIMEOUT_MS;
+}
+/**
+ * Runs a command and returns stdout while preserving child stderr on failure.
+ *
+ * @param {string} command
+ * @param {string[]} args
+ * @param {RunOptions} options
+ * @returns {string}
+ */
+function run(command, args, options) {
+    try {
+        return execFileSync(command, args, {
+            cwd: options.cwd,
+            encoding: 'utf8',
+            env: options.env,
+            stdio: ['ignore', 'pipe', 'inherit'],
+            timeout: resolveCommandTimeoutMs(options.env),
+        });
+    }
+    catch (error) {
+        const failed = error;
+        const stdout = Buffer.isBuffer(failed.stdout) ? failed.stdout.toString('utf8') : String(failed.stdout ?? '');
+        const status = failed.signal === 'SIGTERM' ? 'timeout' : failed.status ?? 'unknown';
+        throw new Error(`${command} ${args.join(' ')} failed with status ${status}\n${stdout}`);
+    }
+}
+/**
+ * Runs a command that must fail and returns captured output.
+ *
+ * @param {string} command
+ * @param {string[]} args
+ * @param {RunOptions} options
+ * @returns {FailedRunOutput}
+ */
+function runExpectFailure(command, args, options) {
+    try {
+        const stdout = execFileSync(command, args, {
+            cwd: options.cwd,
+            encoding: 'utf8',
+            env: options.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: resolveCommandTimeoutMs(options.env),
+        });
+        throw new Error(`Expected command to fail, but it passed with stdout: ${stdout}`);
+    }
+    catch (error) {
+        const failed = error;
+        if (failed.message.startsWith('Expected command to fail')) {
+            throw failed;
+        }
+        return {
+            status: failed.status ?? null,
+            stderr: Buffer.isBuffer(failed.stderr) ? failed.stderr.toString('utf8') : String(failed.stderr ?? ''),
+            stdout: Buffer.isBuffer(failed.stdout) ? failed.stdout.toString('utf8') : String(failed.stdout ?? ''),
+        };
+    }
+}
+/**
+ * Reads and parses a JSON file.
+ *
+ * @param {string} filePath
+ * @returns {Record<string, unknown>}
+ */
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+/**
+ * Writes stable formatted JSON.
+ *
+ * @param {string} filePath
+ * @param {unknown} value
+ * @returns {void}
+ */
+function writeJson(filePath, value) {
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+/**
+ * Resolves a package binary path inside a temporary npm app.
+ *
+ * @param {string} appRoot
+ * @param {string} name
+ * @returns {string}
+ */
+function packageBinPath(appRoot, name) {
+    const suffix = process.platform === 'win32' ? '.cmd' : '';
+    return path.join(appRoot, 'node_modules', '.bin', `${name}${suffix}`);
+}
+/**
+ * Packs the current repo and returns the tarball path.
+ *
+ * @param {{env: NodeJS.ProcessEnv, packageRoot: string, packDir: string}} options
+ * @returns {string}
+ */
+function packPackage({ env, packageRoot, packDir, }) {
+    fs.mkdirSync(packDir, { recursive: true });
+    const packOutput = run('npm', ['pack', '--pack-destination', packDir], {
+        cwd: packageRoot,
+        env,
+    });
+    const tarballName = packOutput.trim().split(/\n/u).pop();
+    assert.ok(tarballName, 'npm pack did not print a tarball name');
+    const tarballPath = path.join(packDir, tarballName);
+    assert.equal(fs.existsSync(tarballPath), true, `missing packed tarball: ${tarballPath}`);
+    return tarballPath;
+}
+/**
+ * Creates an existing app layout before Agent Scenario Loop initialization.
+ *
+ * @param {string} appRoot
+ * @returns {void}
+ */
+function writeExistingAppFixture(appRoot) {
+    fs.mkdirSync(path.join(appRoot, 'src'), { recursive: true });
+    writeJson(path.join(appRoot, 'package.json'), {
+        name: 'consumer-rehearsal-app',
+        private: true,
+        scripts: {
+            start: 'react-native start',
+            test: 'node --version',
+        },
+    });
+    fs.writeFileSync(path.join(appRoot, 'src', 'App.tsx'), [
+        "export function App() {",
+        "  return null;",
+        "}",
+        '',
+    ].join('\n'), 'utf8');
+}
+/**
+ * Writes deterministic profile-event logs for the initialized consumer scenario.
+ *
+ * @param {string} appRoot
+ * @returns {{androidEvents: string, iosEvents: string}}
+ */
+function writeProfileEventFixtures(appRoot) {
+    const eventLogDir = path.join(appRoot, 'event-logs');
+    fs.mkdirSync(eventLogDir, { recursive: true });
+    const iosEvents = path.join(eventLogDir, 'account-overview-ios.log');
+    const androidEvents = path.join(eventLogDir, 'account-overview-android.log');
+    fs.writeFileSync(iosEvents, [
+        '2026-01-01T00:00:00.000Z consumer-ios [profile-event] {"event":"first_journey_started","scenario":"account-overview","runId":"account-overview-ios","iteration":1,"atMs":0}',
+        '2026-01-01T00:00:00.700Z consumer-ios [profile-event] {"event":"first_journey_completed","scenario":"account-overview","runId":"account-overview-ios","iteration":1,"atMs":700}',
+        '2026-01-01T00:00:01.000Z consumer-ios [profile-event] {"event":"first_journey_started","scenario":"account-overview","runId":"account-overview-ios","iteration":2,"atMs":1000}',
+        '2026-01-01T00:00:01.760Z consumer-ios [profile-event] {"event":"first_journey_completed","scenario":"account-overview","runId":"account-overview-ios","iteration":2,"atMs":1760}',
+        '2026-01-01T00:00:02.000Z consumer-ios [profile-event] {"event":"first_journey_started","scenario":"account-overview","runId":"account-overview-ios","iteration":3,"atMs":2000}',
+        '2026-01-01T00:00:02.830Z consumer-ios [profile-event] {"event":"first_journey_completed","scenario":"account-overview","runId":"account-overview-ios","iteration":3,"atMs":2830}',
+        '',
+    ].join('\n'), 'utf8');
+    fs.writeFileSync(androidEvents, [
+        '2026-01-01T00:10:00.000Z consumer-android [profile-event] {"event":"first_journey_started","scenario":"account-overview","runId":"account-overview-android","iteration":1,"atMs":0}',
+        '2026-01-01T00:10:00.820Z consumer-android [profile-event] {"event":"first_journey_completed","scenario":"account-overview","runId":"account-overview-android","iteration":1,"atMs":820}',
+        '2026-01-01T00:10:01.000Z consumer-android [profile-event] {"event":"first_journey_started","scenario":"account-overview","runId":"account-overview-android","iteration":2,"atMs":1000}',
+        '2026-01-01T00:10:01.870Z consumer-android [profile-event] {"event":"first_journey_completed","scenario":"account-overview","runId":"account-overview-android","iteration":2,"atMs":1870}',
+        '2026-01-01T00:10:02.000Z consumer-android [profile-event] {"event":"first_journey_started","scenario":"account-overview","runId":"account-overview-android","iteration":3,"atMs":2000}',
+        '2026-01-01T00:10:02.940Z consumer-android [profile-event] {"event":"first_journey_completed","scenario":"account-overview","runId":"account-overview-android","iteration":3,"atMs":2940}',
+        '',
+    ].join('\n'), 'utf8');
+    return { androidEvents, iosEvents };
+}
+/**
+ * Writes a tiny Argent-compatible command for consumer-script rehearsal.
+ *
+ * @param {string} filePath
+ * @returns {void}
+ */
+function writeFakeArgent(filePath) {
+    const scriptPath = filePath.endsWith('.cmd') ? filePath.replace(/\.cmd$/u, '.js') : filePath;
+    const script = [
+        '#!/usr/bin/env node',
+        "const fs = require('node:fs');",
+        "const path = require('node:path');",
+        "const args = process.argv.slice(2);",
+        "const key = args.join(' ');",
+        "function ok(stdout = '{\"description\":\"Consumer Rehearsal first journey complete\"}\\n') { process.stdout.write(stdout); process.exit(0); }",
+        "if (args.includes('launch-app')) ok('{\"success\":true}\\n');",
+        "if (args.includes('describe')) ok();",
+        "if (args.includes('screenshot')) {",
+        "  const screenshotPath = path.join(path.dirname(process.argv[1]), 'fake-argent-screenshot.png');",
+        "  fs.writeFileSync(screenshotPath, 'fake screenshot', 'utf8');",
+        "  ok(`Saved screenshot: ${screenshotPath}\\n`);",
+        "}",
+        "if (args.includes('gesture-tap')) ok('{\"success\":true}\\n');",
+        "if (args.includes('gesture-swipe')) ok('{\"success\":true}\\n');",
+        "process.stderr.write(`unexpected fake Argent command: ${key}\\n`);",
+        "process.exit(1);",
+        '',
+    ].join('\n');
+    fs.writeFileSync(scriptPath, script, { mode: 0o755 });
+    if (filePath.endsWith('.cmd')) {
+        fs.writeFileSync(filePath, `@echo off\r\n"${process.execPath}" "%~dp0${path.basename(scriptPath)}" %*\r\n`, {
+            mode: 0o755,
+        });
+    }
+}
+/**
+ * Asserts one generated Argent package script can run from the installed app.
+ *
+ * @param {{appRoot: string, env: NodeJS.ProcessEnv, fakeArgentPath: string, platform: 'android' | 'ios'}} options
+ * @returns {void}
+ */
+function assertArgentScriptRuns({ appRoot, env, fakeArgentPath, platform, }) {
+    run('npm', ['run', `asl:argent:${platform}`, '--silent'], {
+        cwd: appRoot,
+        env: {
+            ...env,
+            ASL_ARGENT_BIN: fakeArgentPath,
+        },
+    });
+    const runDir = path.join(appRoot, 'artifacts', 'asl', `argent-${platform}`);
+    const health = readJson(path.join(runDir, 'health.json'));
+    const verdict = readJson(path.join(runDir, 'verdict.json'));
+    const metadata = readJson(path.join(runDir, 'raw', 'argent-metadata.json'));
+    assert.equal(health.healthStatus, 'passed');
+    assert.equal(health.runId, `account-overview-${platform}-argent`);
+    assert.equal(health.scenarioId, 'account-overview');
+    assert.equal(verdict.runId, `account-overview-${platform}-argent`);
+    assert.equal(verdict.scenarioId, 'account-overview');
+    assert.equal(verdict.verdictStatus, 'not_evaluated');
+    assert.deepEqual(metadata.driverActions?.map((action) => action.driverAction), ['launch', 'tap', 'screenshot']);
+    assert.equal(fs.existsSync(path.join(runDir, 'captures', 'fake-argent-screenshot.png')), true);
+}
+/**
+ * Writes a small, valid platform live-proof artifact with all local pointers present.
+ *
+ * @param {{appRoot: string, platform: 'android' | 'ios'}} options
+ * @returns {string}
+ */
+function writeConsumerLiveProofFixture({ appRoot, platform, }) {
+    const scenarioId = 'account-overview';
+    const runId = `${platform}-live-proof-rehearsal`;
+    const platformRoot = path.join(appRoot, 'artifacts', 'asl', `${platform}-live`);
+    const liveProofDir = path.join(platformRoot, '_live-proof', `${platform}-live-proof`);
+    const preflightDir = path.join(platformRoot, 'preflight');
+    const profileDir = path.join(platformRoot, scenarioId, `${scenarioId}-${platform}-live`);
+    const interactionDir = path.join(platformRoot, 'interactions', `${scenarioId}-${platform}-agent-device`);
+    const comparisonBaselineDir = path.join(platformRoot, 'baselines', scenarioId);
+    const comparisonDir = path.join(platformRoot, 'comparisons', scenarioId, `${scenarioId}-${platform}-live`);
+    for (const dir of [
+        liveProofDir,
+        preflightDir,
+        profileDir,
+        interactionDir,
+        path.join(interactionDir, 'captures'),
+        comparisonBaselineDir,
+        comparisonDir,
+    ]) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    for (const summaryPath of [
+        path.join(liveProofDir, 'agent-summary.md'),
+        path.join(preflightDir, 'agent-summary.md'),
+        path.join(profileDir, 'agent-summary.md'),
+        path.join(interactionDir, 'agent-summary.md'),
+        path.join(comparisonDir, 'agent-summary.md'),
+    ]) {
+        fs.writeFileSync(summaryPath, `# ${platform} ${scenarioId} rehearsal\n`, 'utf8');
+    }
+    fs.writeFileSync(path.join(interactionDir, 'captures', 'final.png'), 'fake screenshot', 'utf8');
+    const liveProofPath = path.join(liveProofDir, 'live-proof.json');
+    writeJson(liveProofPath, {
+        schemaVersion: '1.0.0',
+        platform,
+        runId,
+        status: 'passed',
+        outputDir: path.relative(appRoot, liveProofDir),
+        preflight: {
+            runId: `${platform}-preflight`,
+            runDir: path.relative(appRoot, preflightDir),
+            summaryPath: path.relative(appRoot, path.join(preflightDir, 'agent-summary.md')),
+            healthStatus: 'passed',
+            verdictStatus: 'passed',
+        },
+        profiles: [
+            {
+                label: 'startup',
+                scenarioId,
+                runId: `${scenarioId}-${platform}-live`,
+                runDir: path.relative(appRoot, profileDir),
+                summaryPath: path.relative(appRoot, path.join(profileDir, 'agent-summary.md')),
+                healthStatus: 'passed',
+                verdictStatus: 'passed',
+            },
+        ],
+        interactionProofs: [
+            {
+                label: 'agent-device startup',
+                runnerId: 'agent-device',
+                scenarioId,
+                runId: `${scenarioId}-${platform}-agent-device`,
+                runDir: path.relative(appRoot, interactionDir),
+                summaryPath: path.relative(appRoot, path.join(interactionDir, 'agent-summary.md')),
+                healthStatus: 'passed',
+                verdictStatus: 'not_evaluated',
+                captures: {
+                    screenshots: ['captures/final.png'],
+                },
+            },
+        ],
+        comparisons: [
+            {
+                label: 'startup',
+                scenarioId,
+                runId: `${scenarioId}-${platform}-live`,
+                status: 'better',
+                baselineDir: path.relative(appRoot, comparisonBaselineDir),
+                comparisonDir: path.relative(appRoot, comparisonDir),
+                summaryPath: path.relative(appRoot, path.join(comparisonDir, 'agent-summary.md')),
+                reason: null,
+                metricSummary: {
+                    counts: {
+                        better: 1,
+                        worse: 0,
+                        unchanged: 0,
+                        inconclusive: 0,
+                        low_confidence: 0,
+                    },
+                    notableMetrics: [
+                        {
+                            name: 'durationMs.p50',
+                            status: 'better',
+                            unit: 'ms',
+                            baseline: 900,
+                            current: 800,
+                            delta: -100,
+                        },
+                    ],
+                },
+            },
+        ],
+        comparisonCounts: {
+            better: 1,
+            worse: 0,
+            unchanged: 0,
+            mixed: 0,
+            inconclusive: 0,
+            low_confidence: 0,
+            skipped: 0,
+        },
+        comparisonStatus: 'improved',
+        nextAction: {
+            code: 'inspect_summary',
+            summary: 'Inspect the rehearsal proof summary.',
+        },
+        summary: `${platform} rehearsal live proof passed.`,
+    });
+    return path.relative(appRoot, liveProofPath);
+}
+/**
+ * Asserts the generated two-platform live-proof script works from an installed app.
+ *
+ * @param {{appRoot: string, env: NodeJS.ProcessEnv}} options
+ * @returns {void}
+ */
+function assertGeneratedLiveProofGateRuns({ appRoot, env, }) {
+    const androidLiveProof = writeConsumerLiveProofFixture({ appRoot, platform: 'android' });
+    const iosLiveProof = writeConsumerLiveProofFixture({ appRoot, platform: 'ios' });
+    run('npm', ['run', 'asl:live-proof:both', '--silent'], {
+        cwd: appRoot,
+        env: {
+            ...env,
+            ASL_ANDROID_LIVE_PROOF: androidLiveProof,
+            ASL_IOS_LIVE_PROOF: iosLiveProof,
+            ASL_REQUIRE_LIVE_PROOF_ARTIFACTS: '1',
+        },
+    });
+    const proofSet = readJson(path.join(appRoot, 'artifacts', 'asl', 'live-proof-set', 'live-proof-set.json'));
+    const summary = fs.readFileSync(path.join(appRoot, 'artifacts', 'asl', 'live-proof-set', 'agent-summary.md'), 'utf8');
+    assert.equal(proofSet.status, 'passed');
+    assert.deepEqual(proofSet.requiredPlatforms, ['android', 'ios']);
+    assert.deepEqual(proofSet.presentPlatforms, ['android', 'ios']);
+    assert.equal(proofSet.proofCount, 2);
+    assert.equal(proofSet.nextAction.code, 'inspect_summary');
+    assert.match(summary, /Status: passed/u);
+    assert.match(summary, /Present platforms: android, ios/u);
+    assert.match(summary, /android android-live-proof-rehearsal: status=passed comparison=improved/u);
+    assert.match(summary, /ios ios-live-proof-rehearsal: status=passed comparison=improved/u);
+}
+/**
+ * Merges generated Agent Scenario Loop package-script snippets into the app package.json.
+ *
+ * @param {string} appRoot
+ * @returns {Record<string, string>}
+ */
+function mergeGeneratedScripts(appRoot) {
+    const packagePath = path.join(appRoot, 'package.json');
+    const packageJson = readJson(packagePath);
+    const generatedScripts = readJson(path.join(appRoot, 'asl', 'package-scripts.json'));
+    packageJson.scripts = {
+        ...(packageJson.scripts ?? {}),
+        ...generatedScripts,
+    };
+    writeJson(packagePath, packageJson);
+    return generatedScripts;
+}
+/**
+ * Merges the generated runtime-artifact ignore snippet into the fixture app.
+ *
+ * @param {string} appRoot
+ * @returns {void}
+ */
+function mergeGitignoreSnippet(appRoot) {
+    const gitignorePath = path.join(appRoot, '.gitignore');
+    const snippet = fs.readFileSync(path.join(appRoot, 'asl', 'gitignore-snippet'), 'utf8').trim();
+    const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8').trim() : '';
+    fs.writeFileSync(gitignorePath, `${[existing, snippet].filter(Boolean).join('\n\n')}\n`, 'utf8');
+}
+/**
+ * Replaces scaffold placeholders with realistic app identifiers before validation.
+ *
+ * @param {string} appRoot
+ * @returns {void}
+ */
+function replaceConfigPlaceholders(appRoot) {
+    const configPath = path.join(appRoot, 'asl.config.json');
+    const config = readJson(configPath);
+    config.projectName = 'consumer-rehearsal';
+    config.app = {
+        ...(config.app ?? {}),
+        displayName: 'Consumer Rehearsal',
+        scheme: 'consumer-rehearsal',
+        profileSessionScheme: 'consumer-rehearsal',
+        iosBundleId: 'dev.agent-scenario-loop.consumer-rehearsal',
+        androidPackage: 'dev.agentscenarioloop.consumerrehearsal',
+        ios: {
+            ...((config.app ?? {}).ios ?? {}),
+            xcodeScheme: 'ConsumerRehearsal',
+        },
+    };
+    writeJson(configPath, config);
+}
+/**
+ * Asserts that installed project validation rejects stale merged package scripts.
+ *
+ * @param {{appRoot: string, env: NodeJS.ProcessEnv}} options
+ * @returns {void}
+ */
+function assertPackageScriptDriftFails({ appRoot, env, }) {
+    const packagePath = path.join(appRoot, 'package.json');
+    const packageJson = readJson(packagePath);
+    packageJson.scripts['asl:profile:android'] = [
+        'asl-profile-android',
+        '--config asl.config.json',
+        '--scenario scenarios/mobile/account-overview.json',
+        '--comparison-lane stale-android',
+        '--out artifacts/asl/android/stale',
+        '--run-id stale-android',
+    ].join(' ');
+    packageJson.scripts['asl:android:live'] = [
+        'asl-live-android',
+        '--config asl.config.json',
+        '--scenario scenarios/mobile/account-overview.json',
+        '--out artifacts/asl/android-live',
+    ].join(' ');
+    writeJson(packagePath, packageJson);
+    const outDir = path.join(appRoot, 'artifacts', 'asl', 'project-validation-drift');
+    const failure = runExpectFailure(packageBinPath(appRoot, 'asl-validate-project'), [
+        '--root',
+        appRoot,
+        '--platform',
+        'all',
+        '--out',
+        outDir,
+    ], {
+        cwd: appRoot,
+        env,
+    });
+    assert.notEqual(failure.status, 0);
+    assert.match(failure.stdout, /project validation failed/u);
+    assert.match(failure.stdout, /App package\.json ASL script\(s\) differ/u);
+    const validation = readJson(path.join(outDir, 'project-validation.json'));
+    assert.equal(validation.status, 'failed');
+    assert.deepEqual(validation.scripts.mismatchedPackageJsonScripts, ['asl:profile:android', 'asl:android:live']);
+    assert.equal(validation.nextActions.some((action) => action.code === 'merge_package_scripts'), true);
+}
+/**
+ * Asserts that installed project validation rejects invalid path config.
+ *
+ * @param {{appRoot: string, env: NodeJS.ProcessEnv}} options
+ * @returns {void}
+ */
+function assertProjectPathConfigFails({ appRoot, env, }) {
+    const configPath = path.join(appRoot, 'asl.config.json');
+    const originalConfig = readJson(configPath);
+    const brokenConfig = JSON.parse(JSON.stringify(originalConfig));
+    brokenConfig.paths = {
+        ...(brokenConfig.paths ?? {}),
+        androidArtifactsRoot: 42,
+    };
+    delete brokenConfig.paths.scenarioRoot;
+    delete brokenConfig.paths.iosScenarioRoot;
+    delete brokenConfig.paths.androidScenarioRoot;
+    writeJson(configPath, brokenConfig);
+    try {
+        const outDir = path.join(appRoot, 'artifacts', 'asl', 'project-validation-path-config');
+        const failure = runExpectFailure(packageBinPath(appRoot, 'asl-validate-project'), [
+            '--root',
+            appRoot,
+            '--platform',
+            'all',
+            '--out',
+            outDir,
+        ], {
+            cwd: appRoot,
+            env,
+        });
+        assert.notEqual(failure.status, 0);
+        assert.match(failure.stdout, /project validation failed/u);
+        assert.match(failure.stdout, /Project config is missing required field\(s\)/u);
+        assert.match(failure.stdout, /Project config has invalid required field\(s\)/u);
+        const validation = readJson(path.join(outDir, 'project-validation.json'));
+        assert.equal(validation.status, 'failed');
+        assert.equal(validation.config.status, 'incomplete');
+        assert.deepEqual(validation.config.missingFields, [
+            'paths.scenarioRoot or paths.iosScenarioRoot',
+            'paths.scenarioRoot or paths.androidScenarioRoot',
+        ]);
+        assert.deepEqual(validation.config.invalidFields, ['paths.androidArtifactsRoot']);
+        assert.equal(validation.nextActions.some((action) => action.code === 'fix_project_config'), true);
+    }
+    finally {
+        writeJson(configPath, originalConfig);
+    }
+}
+/**
+ * Asserts that the installed package can initialize and validate an existing app.
+ *
+ * @param {{appRoot: string, env: NodeJS.ProcessEnv, tarballPath: string}} options
+ * @returns {void}
+ */
+function rehearseConsumerInstall({ appRoot, env, tarballPath, }) {
+    writeExistingAppFixture(appRoot);
+    run('npm', ['install', tarballPath, '--ignore-scripts'], {
+        cwd: appRoot,
+        env,
+    });
+    run(packageBinPath(appRoot, 'asl-init'), ['--out', appRoot, '--scenario', 'Account Overview'], {
+        cwd: appRoot,
+        env,
+    });
+    const generatedScripts = mergeGeneratedScripts(appRoot);
+    mergeGitignoreSnippet(appRoot);
+    replaceConfigPlaceholders(appRoot);
+    const profileEvents = writeProfileEventFixtures(appRoot);
+    const fakeArgentPath = path.join(appRoot, process.platform === 'win32' ? 'fake-argent.cmd' : 'fake-argent');
+    writeFakeArgent(fakeArgentPath);
+    const packageJson = readJson(path.join(appRoot, 'package.json'));
+    assert.equal(packageJson.scripts.start, 'react-native start');
+    assert.equal(packageJson.scripts.test, 'node --version');
+    for (const scriptName of Object.keys(generatedScripts)) {
+        assert.equal(typeof packageJson.scripts[scriptName], 'string', `${scriptName} should be merged`);
+    }
+    run('npm', ['run', 'asl:check:ios', '--silent'], {
+        cwd: appRoot,
+        env,
+    });
+    run('npm', ['run', 'asl:check:android', '--silent'], {
+        cwd: appRoot,
+        env,
+    });
+    run('npm', ['run', 'asl:profile:ios', '--silent'], {
+        cwd: appRoot,
+        env: { ...env, ASL_PROFILE_IOS_EVENTS: profileEvents.iosEvents },
+    });
+    run('npm', ['run', 'asl:profile:android', '--silent'], {
+        cwd: appRoot,
+        env: { ...env, ASL_PROFILE_ANDROID_EVENTS: profileEvents.androidEvents },
+    });
+    run('npm', ['run', 'asl:profile:ios:provider', '--silent'], {
+        cwd: appRoot,
+        env: { ...env, ASL_PROFILE_IOS_EVENTS: profileEvents.iosEvents },
+    });
+    run('npm', ['run', 'asl:profile:android:provider', '--silent'], {
+        cwd: appRoot,
+        env: { ...env, ASL_PROFILE_ANDROID_EVENTS: profileEvents.androidEvents },
+    });
+    assertArgentScriptRuns({ appRoot, env, fakeArgentPath, platform: 'ios' });
+    assertArgentScriptRuns({ appRoot, env, fakeArgentPath, platform: 'android' });
+    assertGeneratedLiveProofGateRuns({ appRoot, env });
+    run('npm', ['run', 'asl:validate', '--silent'], {
+        cwd: appRoot,
+        env,
+    });
+    const validationPath = path.join(appRoot, 'artifacts', 'asl', 'project-validation', 'project-validation.json');
+    const validation = readJson(validationPath);
+    assert.equal(validation.status, 'passed');
+    assert.equal(validation.appHelper.status, 'present');
+    assert.deepEqual(validation.config.customDrivers, []);
+    assert.deepEqual(validation.config.externalTargetDrivers, ['xcodebuildmcp']);
+    assert.deepEqual(validation.config.packageSupportedDrivers, ['adb', 'agent-device', 'argent', 'fixture-log-ingest', 'ios-simctl']);
+    assert.deepEqual(validation.config.supportedDrivers, ['adb', 'agent-device', 'argent', 'fixture-log-ingest', 'ios-simctl', 'xcodebuildmcp']);
+    assert.deepEqual(validation.config.missingSupportedDrivers, []);
+    const realAppRoot = fs.realpathSync(appRoot);
+    assert.deepEqual(validation.scenarioCandidateDirectories.map((directory) => path.relative(realAppRoot, fs.realpathSync(directory))), [
+        'scenarios',
+        path.join('scenarios', 'mobile'),
+    ]);
+    assert.equal(validation.scripts.status, 'present');
+    assert.equal(validation.scripts.packageJsonStatus, 'present');
+    assert.deepEqual(validation.warnings, []);
+    assert.equal(validation.nextActions.some((action) => action.code === 'replace_config_placeholders'), false);
+    assert.deepEqual(validation.plans
+        .map((plan) => ({
+        healthStatus: plan.healthStatus,
+        platform: plan.platform,
+        scenarioId: plan.scenarioId,
+    }))
+        .sort((left, right) => left.platform.localeCompare(right.platform)), [
+        { healthStatus: 'passed', platform: 'android', scenarioId: 'account-overview' },
+        { healthStatus: 'passed', platform: 'ios', scenarioId: 'account-overview' },
+    ]);
+    for (const [platform, runId] of [['ios', 'account-overview-ios'], ['android', 'account-overview-android']]) {
+        const runDir = path.join(appRoot, 'artifacts', 'asl', platform, 'account-overview', runId);
+        const health = readJson(path.join(runDir, 'health.json'));
+        const verdict = readJson(path.join(runDir, 'verdict.json'));
+        assert.equal(health.healthStatus, 'passed');
+        assert.equal(verdict.verdictStatus, 'passed');
+    }
+    for (const [platform, runId] of [
+        ['ios', 'account-overview-ios-provider'],
+        ['android', 'account-overview-android-provider'],
+    ]) {
+        const providerRunDir = path.join(appRoot, 'artifacts', 'asl', platform, 'account-overview', runId);
+        const providerManifest = readJson(path.join(providerRunDir, 'manifest.json'));
+        assert.deepEqual(providerManifest.artifacts?.signals?.js, ['signals/js/profiler.json']);
+        assert.deepEqual(providerManifest.artifacts?.signals?.memory, ['signals/memory/memory.json']);
+        assert.deepEqual(providerManifest.artifacts?.signals?.network, ['signals/network/network.har']);
+        assert.deepEqual(providerManifest.artifacts?.evidenceAttachments?.map((attachment) => ({
+            channel: attachment.channel,
+            kind: attachment.kind,
+            path: attachment.path,
+            sourceFileName: attachment.sourceFileName,
+        })), [
+            {
+                channel: 'provider',
+                kind: 'accessibility',
+                path: 'raw/providers/example-evidence-provider/accessibility.json',
+                sourceFileName: 'accessibility.json',
+            },
+            {
+                channel: 'provider',
+                kind: 'profiler',
+                path: 'raw/providers/example-evidence-provider/profiler.json',
+                sourceFileName: 'profiler.json',
+            },
+            {
+                channel: 'signal',
+                kind: 'js',
+                path: 'signals/js/profiler.json',
+                sourceFileName: 'profiler.json',
+            },
+            {
+                channel: 'signal',
+                kind: 'memory',
+                path: 'signals/memory/memory.json',
+                sourceFileName: 'memory.json',
+            },
+            {
+                channel: 'signal',
+                kind: 'network',
+                path: 'signals/network/network.har',
+                sourceFileName: 'network.har',
+            },
+        ]);
+    }
+    assertProjectPathConfigFails({ appRoot, env });
+    assertPackageScriptDriftFails({ appRoot, env });
+}
+/**
+ * Runs the packed-package consumer rehearsal.
+ *
+ * @returns {void}
+ */
+function main() {
+    const packageRoot = path.resolve(__dirname, '..', '..');
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'asl-consumer-rehearsal-'));
+    const env = createRehearsalEnv(tempRoot);
+    const appRoot = path.join(tempRoot, 'existing-mobile-app');
+    fs.mkdirSync(appRoot, { recursive: true });
+    try {
+        const tarballPath = packPackage({
+            env,
+            packageRoot,
+            packDir: path.join(tempRoot, 'pack'),
+        });
+        rehearseConsumerInstall({
+            appRoot,
+            env,
+            tarballPath,
+        });
+        process.stdout.write(`consumer rehearsal passed: ${appRoot}\n`);
+    }
+    catch (error) {
+        console.error(`consumer rehearsal temp kept at: ${tempRoot}`);
+        throw error;
+    }
+}
+if (require.main === module) {
+    try {
+        main();
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}