@playdrop/playdrop-cli 0.13.6 → 0.13.7

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.13.5",
+  "version": "0.13.7",
   "build": 1,
-  "runtimeSdkVersion": "0.13.5",
+  "runtimeSdkVersion": "0.13.7",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/dist/apps/index.d.ts

@@ -26,7 +26,7 @@ export type AppPipelineOptions = {
     agentTaskId?: number;
     playtestProof?: AgentTaskPlaytestProof;
     mediaCaptureRequired?: boolean;
-    machineCausalGateRequired?: boolean;
+    playtestSmokeCheckRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
     artifacts?: AppBuildArtifacts;
 };

package/dist/apps/index.js

@@ -67,7 +67,7 @@ async function runAppPipeline(client, task, options) {
         agentTaskId: options?.agentTaskId,
         playtestProof: options?.playtestProof,
         mediaCaptureRequired: options?.mediaCaptureRequired,
-        machineCausalGateRequired: options?.machineCausalGateRequired,
+        playtestSmokeCheckRequired: options?.playtestSmokeCheckRequired,
         captureSession: options?.captureSession,
     };
     const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);

package/dist/apps/loadCheck.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
-import { type AppPlaytestTape, type AppSurface, type AppUploadCausalComparison, type AppUploadMachineCausalEvidence, type UserResponse } from '@playdrop/types';
+import { type AppPlaytestTape, type AppPlaytestTapeEvent, type AppSurface, type AppUploadCausalComparison, type AppUploadMachineCausalEvidence, type UserResponse } from '@playdrop/types';
 import type { BrowserContextOptions, Frame, Page } from 'playwright-core';
 import type { AppTask } from '../catalogue';
 import { type TaskCaptureSession } from '../appUrls';
@@ -52,7 +52,9 @@ export declare function focusProjectCheckGameFrame(page: Pick<Page, 'mouse'>, fr
     width: number;
     height: number;
 }>;
-export declare function dispatchPlaytestTapeToFrame(page: Page, frame: Frame, surface: AppSurface, tape: AppPlaytestTape): Promise<void>;
+export declare function dispatchPlaytestTapeToFrame(page: Page, frame: Frame, surface: AppSurface, tape: AppPlaytestTape, hooks?: {
+    onBeforeEvent?: (eventIndex: number, event: AppPlaytestTapeEvent) => void;
+}): Promise<void>;
 export declare function dispatchProjectCheckActionsToFrame(page: Page, frame: Frame, actions: readonly ProjectCheckAction[]): Promise<void>;
 export declare function formatHostedLoadCheckFailure(taskName: string, result: HostedLoadCheckResult, scope?: 'local' | 'staged' | 'final'): string;
 export declare function redactHostedLoadCheckSecrets(text: string, sourceUrl: string): string;
@@ -89,17 +91,15 @@ export declare function runUploadedHostedLoadCheck(input: {
     playtestTape?: AppPlaytestTape;
     postReadyWaitMs?: number;
 }): Promise<HostedLoadCheckResult>;
-export declare function sliceFirstPrimaryVerbAction(tape: AppPlaytestTape): AppPlaytestTape;
-export declare function compareCausalFrames(firstPath: string, secondPath: string, thresholds?: {
+export declare function comparePlaytestFrames(firstPath: string, secondPath: string, thresholds?: {
     meanDeltaMin: number;
     changedPixelRatioMin: number;
 }): Promise<AppUploadCausalComparison>;
-export declare function runUploadedHostedCausalCheck(input: {
+export declare function runUploadedHostedPlaytestSmokeCheck(input: {
     client: ApiClient;
     creatorUsername: string;
     task: AppTask;
     sessionId: string;
-    teachingText: string;
     timeoutMs?: number;
     token?: string | null;
     currentUser?: UserResponse | null;

package/dist/apps/loadCheck.js

@@ -15,9 +15,8 @@ exports.formatHostedLoadCheckFailure = formatHostedLoadCheckFailure;
 exports.redactHostedLoadCheckSecrets = redactHostedLoadCheckSecrets;
 exports.runLocalHostedLoadCheck = runLocalHostedLoadCheck;
 exports.runUploadedHostedLoadCheck = runUploadedHostedLoadCheck;
-exports.sliceFirstPrimaryVerbAction = sliceFirstPrimaryVerbAction;
-exports.compareCausalFrames = compareCausalFrames;
-exports.runUploadedHostedCausalCheck = runUploadedHostedCausalCheck;
+exports.comparePlaytestFrames = comparePlaytestFrames;
+exports.runUploadedHostedPlaytestSmokeCheck = runUploadedHostedPlaytestSmokeCheck;
 const types_1 = require("@playdrop/types");
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
@@ -39,12 +38,8 @@ Object.defineProperty(exports, "PLAYDROP_SURFACE_CONTEXT_OPTIONS", { enumerable:
 const FRAME_SELECTOR = 'iframe[title="Game"]';
 const DEFAULT_HOSTED_LOAD_TIMEOUT_MS = 15000;
 const POST_READY_SETTLE_MS = 750;
-const CAUSAL_FRAME_MEAN_DELTA_MIN = 0.025;
-const CAUSAL_FRAME_CHANGED_PIXEL_RATIO_MIN = 0.12;
-const CAUSAL_START_FRAME_MEAN_DELTA_MIN = 0.02;
-const CAUSAL_START_FRAME_CHANGED_PIXEL_RATIO_MIN = 0.08;
-const CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN = 0.012;
-const CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN = 0.05;
+const PLAYTEST_INTERACTIVE_MEAN_DELTA_MIN = 0.002;
+const PLAYTEST_INTERACTIVE_CHANGED_PIXEL_RATIO_MIN = 0.01;
 const LOAD_CHECK_SURFACE_ORDER = ['DESKTOP', 'MOBILE_LANDSCAPE', 'MOBILE_PORTRAIT'];
 const GOOGLE_TELEMETRY_HOSTS = [
     'analytics.google.com',
@@ -370,78 +365,86 @@ async function dispatchTouchPoints(session, type, points) {
         })),
     });
 }
-async function dispatchPlaytestTapeToFrame(page, frame, surface, tape) {
+async function dispatchPlaytestTapeToFrame(page, frame, surface, tape, hooks = {}) {
     const box = await prepareProjectCheckGameFrame(frame);
     const mobile = surface !== 'DESKTOP';
     const session = mobile ? await page.context().newCDPSession(page) : null;
     const touchPoints = new Map();
     const startedAt = Date.now();
     try {
-        for (const event of tape.events) {
-            const waitMs = event.atMs - (Date.now() - startedAt);
-            if (waitMs > 0) {
-                await page.waitForTimeout(waitMs);
-            }
-            if (event.type === 'keyDown') {
-                await page.keyboard.down(event.key);
-                continue;
-            }
-            if (event.type === 'keyUp') {
-                await page.keyboard.up(event.key);
-                continue;
-            }
-            if (!('x' in event) || !('y' in event)) {
-                throw new Error(`project_check_playtest_event_unsupported:${event.type}`);
-            }
-            const point = resolveTapePoint(box, event);
-            const pointerId = 'pointerId' in event ? event.pointerId ?? 0 : 0;
-            if (event.type === 'tap') {
-                if (mobile && session) {
-                    touchPoints.set(pointerId, point);
-                    await dispatchTouchPoints(session, 'touchStart', touchPoints);
-                    await page.waitForTimeout(event.durationMs ?? types_1.APP_PLAYTEST_DEFAULT_TAP_DURATION_MS);
-                    touchPoints.delete(pointerId);
-                    await dispatchTouchPoints(session, 'touchEnd', touchPoints);
+        for (const [eventIndex, event] of tape.events.entries()) {
+            hooks.onBeforeEvent?.(eventIndex, event);
+            try {
+                const waitMs = event.atMs - (Date.now() - startedAt);
+                if (waitMs > 0) {
+                    await page.waitForTimeout(waitMs);
                 }
-                else {
-                    await page.mouse.move(point.x, point.y);
-                    await page.mouse.down({ button: 'left' });
-                    await page.waitForTimeout(event.durationMs ?? types_1.APP_PLAYTEST_DEFAULT_TAP_DURATION_MS);
-                    await page.mouse.up({ button: 'left' });
+                if (event.type === 'keyDown') {
+                    await page.keyboard.down(event.key);
+                    continue;
                 }
-                continue;
-            }
-            if (event.type === 'pointerDown') {
-                if (mobile && session) {
-                    touchPoints.set(pointerId, point);
-                    await dispatchTouchPoints(session, 'touchStart', touchPoints);
+                if (event.type === 'keyUp') {
+                    await page.keyboard.up(event.key);
+                    continue;
                 }
-                else {
-                    await page.mouse.move(point.x, point.y);
-                    await page.mouse.down({ button: 'left' });
+                if (!('x' in event) || !('y' in event)) {
+                    throw new Error(`project_check_playtest_event_unsupported:${event.type}`);
                 }
-                continue;
-            }
-            if (event.type === 'pointerMove') {
-                if (mobile && session) {
-                    touchPoints.set(pointerId, point);
-                    await dispatchTouchPoints(session, 'touchMove', touchPoints);
+                const point = resolveTapePoint(box, event);
+                const pointerId = 'pointerId' in event ? event.pointerId ?? 0 : 0;
+                if (event.type === 'tap') {
+                    if (mobile && session) {
+                        touchPoints.set(pointerId, point);
+                        await dispatchTouchPoints(session, 'touchStart', touchPoints);
+                        await page.waitForTimeout(event.durationMs ?? types_1.APP_PLAYTEST_DEFAULT_TAP_DURATION_MS);
+                        touchPoints.delete(pointerId);
+                        await dispatchTouchPoints(session, 'touchEnd', touchPoints);
+                    }
+                    else {
+                        await page.mouse.move(point.x, point.y);
+                        await page.mouse.down({ button: 'left' });
+                        await page.waitForTimeout(event.durationMs ?? types_1.APP_PLAYTEST_DEFAULT_TAP_DURATION_MS);
+                        await page.mouse.up({ button: 'left' });
+                    }
+                    continue;
                 }
-                else {
-                    await page.mouse.move(point.x, point.y);
+                if (event.type === 'pointerDown') {
+                    if (mobile && session) {
+                        touchPoints.set(pointerId, point);
+                        await dispatchTouchPoints(session, 'touchStart', touchPoints);
+                    }
+                    else {
+                        await page.mouse.move(point.x, point.y);
+                        await page.mouse.down({ button: 'left' });
+                    }
+                    continue;
                 }
-                continue;
-            }
-            if (event.type === 'pointerUp') {
-                if (mobile && session) {
-                    touchPoints.delete(pointerId);
-                    await dispatchTouchPoints(session, 'touchEnd', touchPoints);
+                if (event.type === 'pointerMove') {
+                    if (mobile && session) {
+                        touchPoints.set(pointerId, point);
+                        await dispatchTouchPoints(session, 'touchMove', touchPoints);
+                    }
+                    else {
+                        await page.mouse.move(point.x, point.y);
+                    }
+                    continue;
                 }
-                else {
-                    await page.mouse.move(point.x, point.y);
-                    await page.mouse.up({ button: 'left' });
+                if (event.type === 'pointerUp') {
+                    if (mobile && session) {
+                        touchPoints.delete(pointerId);
+                        await dispatchTouchPoints(session, 'touchEnd', touchPoints);
+                    }
+                    else {
+                        await page.mouse.move(point.x, point.y);
+                        await page.mouse.up({ button: 'left' });
+                    }
                 }
             }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                throw new Error(`project_check_playtest_action_failed: action ${eventIndex + 1} of ${tape.events.length} `
+                    + `(${event.type} at ${event.atMs} ms) failed: ${detail}`);
+            }
         }
         const remainingMs = tape.durationMs - (Date.now() - startedAt);
         if (remainingMs > 0) {
@@ -581,6 +584,8 @@ async function runHostedLoadCheck(options) {
             const shouldBootstrapSavedSession = options.savedSessionBootstrap !== false && hasExplicitToken;
             const bootstrapToken = shouldBootstrapSavedSession ? options.token?.trim() || null : null;
             const bootstrapUser = shouldBootstrapSavedSession ? options.user ?? null : null;
+            let currentTapeAction = '';
+            const withTapeAction = (line) => (currentTapeAction ? `${line} after ${currentTapeAction}` : line);
             let hostedLaunchWaiterSettled = false;
             let resolveHostedLaunchWaiter = null;
             const hostedLaunchWaiter = new Promise((resolve) => {
@@ -672,7 +677,7 @@ async function runHostedLoadCheck(options) {
                 const type = message.type();
                 const args = await Promise.all(message.args().map((arg) => arg.jsonValue().catch(() => arg.toString())));
                 const rendered = args.length > 0 ? args.map(formatConsoleValue).join(' ') : message.text();
-                const line = redactReportText(`[check][console:${type}] ${rendered}`);
+                const line = redactReportText(withTapeAction(`[check][console:${type}] ${rendered}`));
                 if (type === 'error' || type === 'assert' || type === 'trace') {
                     errors.push(line);
                     console.error(line);
@@ -688,8 +693,9 @@ async function runHostedLoadCheck(options) {
             });
             page.on('pageerror', (error) => {
                 const text = redactReportText(error?.message ?? String(error));
-                errors.push(`[check][pageerror] ${text}`);
-                console.error(`[check][pageerror] ${text}`);
+                const line = withTapeAction(`[check][pageerror] ${text}`);
+                errors.push(line);
+                console.error(line);
             });
             page.on('requestfailed', (request) => {
                 const failure = request.failure();
@@ -702,8 +708,9 @@ async function runHostedLoadCheck(options) {
                 if (/ERR_ABORTED/i.test(errorText) || /ERR_HTTP2_PROTOCOL_ERROR/i.test(errorText)) {
                     return;
                 }
-                errors.push(`[check][requestfailed] ${text}`);
-                console.error(`[check][requestfailed] ${text}`);
+                const line = withTapeAction(`[check][requestfailed] ${text}`);
+                errors.push(line);
+                console.error(line);
             });
             page.on('response', (response) => {
                 const status = response.status();
@@ -715,8 +722,9 @@ async function runHostedLoadCheck(options) {
                     warnings.push(`[check][response] ${text}`);
                     return;
                 }
-                errors.push(`[check][response] ${text}`);
-                console.error(`[check][response] ${text}`);
+                const line = withTapeAction(`[check][response] ${text}`);
+                errors.push(line);
+                console.error(line);
             });
             console.log(`[check] Opening ${reportTargetUrl}`);
             const response = await page.goto(options.targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
@@ -768,7 +776,11 @@ async function runHostedLoadCheck(options) {
                 if (!options.playtestSurface) {
                     throw new Error('project_check_playtest_surface_required');
                 }
-                await dispatchPlaytestTapeToFrame(page, frame, options.playtestSurface, options.playtestTape);
+                await dispatchPlaytestTapeToFrame(page, frame, options.playtestSurface, options.playtestTape, {
+                    onBeforeEvent: (eventIndex, event) => {
+                        currentTapeAction = `action ${eventIndex + 1} of ${options.playtestTape.events.length} (${event.type} at ${event.atMs} ms)`;
+                    },
+                });
             }
             else if (options.actions?.length) {
                 await dispatchProjectCheckActionsToFrame(page, frame, options.actions);
@@ -1082,55 +1094,12 @@ async function runUploadedHostedLoadCheck(input) {
         artifactFingerprint: recordedLaunchCheck.artifactFingerprint,
     };
 }
-function sliceFirstPrimaryVerbAction(tape) {
-    const prefix = tape.events.slice(0, tape.startOnlyEventCount);
-    const postStartEvents = tape.events.slice(tape.startOnlyEventCount);
-    let actionEventCount = 0;
-    if (tape.primaryVerb === 'tap') {
-        actionEventCount = 1;
-    }
-    else if (tape.primaryVerb === 'key') {
-        const activeKeys = new Set();
-        for (let index = 0; index < postStartEvents.length; index += 1) {
-            const event = postStartEvents[index];
-            if (event.type === 'keyDown')
-                activeKeys.add(event.key);
-            if (event.type === 'keyUp')
-                activeKeys.delete(event.key);
-            if (activeKeys.size === 0 && index > 0) {
-                actionEventCount = index + 1;
-                break;
-            }
-        }
-    }
-    else {
-        const activePointers = new Set();
-        for (let index = 0; index < postStartEvents.length; index += 1) {
-            const event = postStartEvents[index];
-            if (event.type === 'pointerDown')
-                activePointers.add(event.pointerId ?? 0);
-            if (event.type === 'pointerUp')
-                activePointers.delete(event.pointerId ?? 0);
-            if (activePointers.size === 0 && index > 0) {
-                actionEventCount = index + 1;
-                break;
-            }
-        }
-    }
-    if (actionEventCount <= 0) {
-        throw new Error(`agent_task_machine_causal_gate_invalid_tape:first_${tape.primaryVerb}_action_incomplete`);
-    }
-    return {
-        ...tape,
-        events: [...prefix, ...postStartEvents.slice(0, actionEventCount)],
-    };
-}
 async function hashFile(path) {
     return (0, node_crypto_1.createHash)('sha256').update(await (0, promises_1.readFile)(path)).digest('hex');
 }
-async function compareCausalFrames(firstPath, secondPath, thresholds = {
-    meanDeltaMin: CAUSAL_FRAME_MEAN_DELTA_MIN,
-    changedPixelRatioMin: CAUSAL_FRAME_CHANGED_PIXEL_RATIO_MIN,
+async function comparePlaytestFrames(firstPath, secondPath, thresholds = {
+    meanDeltaMin: PLAYTEST_INTERACTIVE_MEAN_DELTA_MIN,
+    changedPixelRatioMin: PLAYTEST_INTERACTIVE_CHANGED_PIXEL_RATIO_MIN,
 }) {
     const readPixels = async (path) => {
         return await (0, sharp_1.default)(path)
@@ -1141,7 +1110,7 @@ async function compareCausalFrames(firstPath, secondPath, thresholds = {
     };
     const [first, second] = await Promise.all([readPixels(firstPath), readPixels(secondPath)]);
     if (first.length !== second.length || first.length === 0) {
-        throw new Error('agent_task_machine_causal_gate_frame_shape_mismatch');
+        throw new Error('playtest_smoke_check_frame_shape_mismatch: idle and tape screenshots have different dimensions');
     }
     let deltaTotal = 0;
     let changedPixels = 0;
@@ -1159,30 +1128,19 @@ async function compareCausalFrames(firstPath, secondPath, thresholds = {
         passed: meanDelta >= thresholds.meanDeltaMin || changedPixelRatio >= thresholds.changedPixelRatioMin,
     };
 }
-async function runUploadedHostedCausalCheck(input) {
+async function runUploadedHostedPlaytestSmokeCheck(input) {
     const primarySurface = input.task.primarySurface;
     const fullTape = primarySurface ? input.task.playtestTapes?.[primarySurface] : null;
     if (!primarySurface || !fullTape) {
-        throw new Error('agent_task_machine_causal_gate_primary_tape_required');
+        throw new Error('agent_task_playtest_smoke_check_primary_tape_required');
     }
-    if (fullTape.startOnlyEventCount <= 0) {
-        throw new Error('agent_task_machine_causal_gate_start_only_required');
-    }
-    const startOnlyTape = {
-        ...fullTape,
-        events: fullTape.events.slice(0, fullTape.startOnlyEventCount),
-    };
-    const firstActionTape = sliceFirstPrimaryVerbAction(fullTape);
-    const tempDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'playdrop-causal-gate-'));
+    const tempDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'playdrop-playtest-smoke-'));
     const paths = {
         zeroInput: (0, node_path_1.join)(tempDir, 'zero-input.png'),
-        startOnlyReady: (0, node_path_1.join)(tempDir, 'start-only-ready.png'),
-        startOnly: (0, node_path_1.join)(tempDir, 'start-only.png'),
-        firstAction: (0, node_path_1.join)(tempDir, 'first-action.png'),
         fullTape: (0, node_path_1.join)(tempDir, 'full-tape.png'),
     };
     const run = async (label, options) => {
-        console.log(`[upload] Machine causal gate: ${label} from sdk.host.ready().`);
+        console.log(`[upload] Playtest smoke check: ${label} from sdk.host.ready().`);
         const result = await runUploadedHostedLoadCheck({
             client: input.client,
             creatorUsername: input.creatorUsername,
@@ -1195,10 +1153,11 @@ async function runUploadedHostedCausalCheck(input) {
             ...options,
         });
         if (result.status !== 'PASSED') {
-            throw new Error(`Machine causal ${label} run failed. ${formatHostedLoadCheckFailure(input.task.name, result, 'staged')}`);
+            throw new Error(`agent_task_playtest_smoke_check_runtime_failed: ${label} failed. `
+                + formatHostedLoadCheckFailure(input.task.name, result, 'staged'));
         }
         if (!result.artifactFingerprint) {
-            throw new Error('agent_task_machine_causal_gate_artifact_fingerprint_missing');
+            throw new Error('agent_task_playtest_smoke_check_artifact_fingerprint_missing');
         }
         return result;
     };
@@ -1207,87 +1166,38 @@ async function runUploadedHostedCausalCheck(input) {
             postReadyWaitMs: fullTape.durationMs,
             gameFrameScreenshotPath: paths.zeroInput,
         });
-        const startOnly = await run('start-only', {
-            playtestTape: startOnlyTape,
-            readyGameFrameScreenshotPath: paths.startOnlyReady,
-            gameFrameScreenshotPath: paths.startOnly,
-        });
-        const firstAction = await run('first-action', {
-            playtestTape: firstActionTape,
-            gameFrameScreenshotPath: paths.firstAction,
-        });
         const full = await run('full-tape', {
             playtestTape: fullTape,
             gameFrameScreenshotPath: paths.fullTape,
         });
         const artifactFingerprint = full.artifactFingerprint;
-        if ([zeroInput, startOnly, firstAction].some((result) => result.artifactFingerprint !== artifactFingerprint)) {
-            throw new Error('agent_task_machine_causal_gate_artifact_changed_during_check');
-        }
-        const comparisons = {
-            startOnlyVsReady: await compareCausalFrames(paths.startOnlyReady, paths.startOnly, {
-                meanDeltaMin: CAUSAL_START_FRAME_MEAN_DELTA_MIN,
-                changedPixelRatioMin: CAUSAL_START_FRAME_CHANGED_PIXEL_RATIO_MIN,
-            }),
-            startOnlyVsZeroInput: await compareCausalFrames(paths.zeroInput, paths.startOnly, {
-                meanDeltaMin: CAUSAL_START_FRAME_MEAN_DELTA_MIN,
-                changedPixelRatioMin: CAUSAL_START_FRAME_CHANGED_PIXEL_RATIO_MIN,
-            }),
-            fullTapeVsZeroInput: await compareCausalFrames(paths.zeroInput, paths.fullTape, {
-                meanDeltaMin: CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN,
-                changedPixelRatioMin: CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN,
-            }),
-            fullTapeVsStartOnly: await compareCausalFrames(paths.startOnly, paths.fullTape, {
-                meanDeltaMin: CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN,
-                changedPixelRatioMin: CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN,
-            }),
-            fullTapeVsFirstAction: await compareCausalFrames(paths.firstAction, paths.fullTape, {
-                meanDeltaMin: CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN,
-                changedPixelRatioMin: CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN,
-            }),
-        };
-        if (!comparisons.startOnlyVsReady.passed || !comparisons.startOnlyVsZeroInput.passed) {
-            throw new Error(`agent_task_machine_causal_gate_failed:start-only did not provably leave the title state. `
-                + `ready(mean=${comparisons.startOnlyVsReady.meanDelta.toFixed(4)},changed=${comparisons.startOnlyVsReady.changedPixelRatio.toFixed(4)}); `
-                + `zero(mean=${comparisons.startOnlyVsZeroInput.meanDelta.toFixed(4)},changed=${comparisons.startOnlyVsZeroInput.changedPixelRatio.toFixed(4)}). `
-                + 'Fix the start action, visible start-only outcome, or ready-relative timing.');
-        }
-        if (!comparisons.fullTapeVsZeroInput.passed || !comparisons.fullTapeVsStartOnly.passed) {
-            throw new Error(`agent_task_machine_causal_gate_failed:full tape did not meaningfully beat zero-input and start-only controls. `
-                + `zero(mean=${comparisons.fullTapeVsZeroInput.meanDelta.toFixed(4)},changed=${comparisons.fullTapeVsZeroInput.changedPixelRatio.toFixed(4)}); `
-                + `start(mean=${comparisons.fullTapeVsStartOnly.meanDelta.toFixed(4)},changed=${comparisons.fullTapeVsStartOnly.changedPixelRatio.toFixed(4)}). `
-                + 'Fix the game or tape before upload.');
+        if (zeroInput.artifactFingerprint !== artifactFingerprint) {
+            throw new Error('agent_task_playtest_smoke_check_artifact_changed_during_check');
         }
-        if (!comparisons.fullTapeVsFirstAction.passed) {
-            throw new Error(`agent_task_machine_causal_gate_failed:first primary action trivially reached the full-tape outcome. `
-                + `action(mean=${comparisons.fullTapeVsFirstAction.meanDelta.toFixed(4)},changed=${comparisons.fullTapeVsFirstAction.changedPixelRatio.toFixed(4)}). `
-                + 'Add a sustained causal loop before upload.');
+        const comparison = await comparePlaytestFrames(paths.zeroInput, paths.fullTape);
+        if (!comparison.passed) {
+            throw new Error(`agent_task_playtest_smoke_check_not_interactive: The validator completed all ${fullTape.events.length} tape actions `
+                + `without a crash, but the result looked the same as running the game for ${fullTape.durationMs} ms without input `
+                + `(mean pixel change ${comparison.meanDelta.toFixed(4)}, changed pixels ${(comparison.changedPixelRatio * 100).toFixed(2)}%). `
+                + 'Make sure the tape performs the core gameplay action and produces a visible response, then rerun the tape check.');
         }
-        const teachingText = input.teachingText.trim();
         const evidence = {
-            version: 1,
+            version: 2,
             source: 'CLI_MACHINE',
             artifactFingerprint,
             primarySurface,
             primaryVerb: fullTape.primaryVerb,
             runs: {
                 zeroInput: { finalFrameSha256: await hashFile(paths.zeroInput) },
-                startOnly: {
-                    readyFrameSha256: await hashFile(paths.startOnlyReady),
-                    finalFrameSha256: await hashFile(paths.startOnly),
-                },
-                firstAction: { finalFrameSha256: await hashFile(paths.firstAction) },
                 fullTape: { finalFrameSha256: await hashFile(paths.fullTape) },
             },
-            comparisons,
-            teachingText,
-            teachingTextSha256: (0, node_crypto_1.createHash)('sha256').update(teachingText).digest('hex'),
+            comparison,
         };
         const recorded = await input.client.recordAppUploadCausalCheck(input.creatorUsername, input.task.name, input.sessionId, { evidence });
         if (recorded.session.causalCheck.status !== 'PASSED') {
-            throw new Error('agent_task_machine_causal_gate_not_recorded');
+            throw new Error('agent_task_playtest_smoke_check_not_recorded');
         }
-        console.log(`[upload] Machine causal gate passed for ${input.creatorUsername}/${input.task.name}.`);
+        console.log(`[upload] Playtest smoke check passed for ${input.creatorUsername}/${input.task.name}.`);
         return evidence;
     }
     finally {

package/dist/apps/upload.d.ts

@@ -23,7 +23,7 @@ export type AppUploadOptions = {
     agentTaskId?: number;
     playtestProof?: AgentTaskPlaytestProof;
     mediaCaptureRequired?: boolean;
-    machineCausalGateRequired?: boolean;
+    playtestSmokeCheckRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
 };
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;

package/dist/apps/upload.js

@@ -9,7 +9,6 @@ const node_path_1 = require("node:path");
 const http_1 = require("../http");
 const loadCheck_1 = require("./loadCheck");
 const listingPreflight_1 = require("../listingPreflight");
-const playtestContract_1 = require("./playtestContract");
 const EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -355,14 +354,12 @@ async function uploadAppVersion(client, task, artifacts, options) {
             }
             if (task.hostingMode !== 'EXTERNAL'
                 && !task.externalUrl
-                && options?.machineCausalGateRequired) {
-                const teachingText = (0, playtestContract_1.assertPrimaryVerbTeachingParity)(task);
-                await (0, loadCheck_1.runUploadedHostedCausalCheck)({
+                && options?.playtestSmokeCheckRequired) {
+                await (0, loadCheck_1.runUploadedHostedPlaytestSmokeCheck)({
                     client,
                     creatorUsername,
                     task,
                     sessionId,
-                    teachingText,
                     timeoutMs: options.loadCheckTimeoutMs,
                     token: options?.token ?? null,
                     currentUser: options?.user ?? null,

package/dist/commands/check.js

@@ -222,7 +222,6 @@ async function check(targetArg, options = {}) {
         });
         if (tapeSurface && playtestTape) {
             const idleScreenshotPath = buildComparisonScreenshotPath(screenshotPath, 'idle');
-            const startOnlyScreenshotPath = buildComparisonScreenshotPath(screenshotPath, 'start-only');
             const tapeScreenshotPath = buildComparisonScreenshotPath(screenshotPath, 'tape');
             console.log(`[check] Running ${playtestTape.durationMs} ms zero-input baseline on ${tapeSurface}.`);
             const idleResult = await runCheck({
@@ -235,22 +234,6 @@ async function check(targetArg, options = {}) {
                 process.exitCode = 1;
                 return;
             }
-            console.log(`[check] Reopening a clean run and executing only the first ${playtestTape.startOnlyEventCount} startup event(s).`);
-            const startOnlyTape = playtestTape.startOnlyEventCount > 0
-                ? { ...playtestTape, events: playtestTape.events.slice(0, playtestTape.startOnlyEventCount) }
-                : null;
-            const startOnlyResult = await runCheck({
-                screenshotPath: startOnlyScreenshotPath,
-                surface: tapeSurface,
-                ...(startOnlyTape
-                    ? { tape: startOnlyTape }
-                    : { postReadyWaitMs: playtestTape.durationMs }),
-            });
-            if (startOnlyResult.status !== 'PASSED') {
-                (0, messages_1.printErrorWithHelp)((0, loadCheck_1.formatHostedLoadCheckFailure)(appName, startOnlyResult, 'local'), startOnlyResult.screenshotPath ? [`Start-only screenshot: ${startOnlyResult.screenshotPath}`] : [], { command: 'project check' });
-                process.exitCode = 1;
-                return;
-            }
             console.log(`[check] Reopening a clean run and executing the ${tapeSurface} tape.`);
             const tapeResult = await runCheck({
                 screenshotPath: tapeScreenshotPath,
@@ -262,14 +245,23 @@ async function check(targetArg, options = {}) {
                 process.exitCode = 1;
                 return;
             }
-            console.log(`[check] Captured matched idle, start-only, and tape runs for ${currentUsername}/${appName}.`);
-            console.log(`[check] Idle: ${idleResult.screenshotPath ?? idleScreenshotPath}`);
-            console.log(`[check] Start-only: ${startOnlyResult.screenshotPath ?? startOnlyScreenshotPath}`);
-            console.log(`[check] Tape: ${tapeResult.screenshotPath ?? tapeScreenshotPath}`);
-            console.log('[check] The tape passes only when visible evidence shows it meaningfully beats both controls.');
-            for (const signal of playtestTape.successSignals) {
-                console.log(`[check] Success signal ${signal.kind}: ${signal.description}`);
+            const idleCapture = idleResult.screenshotPath ?? idleScreenshotPath;
+            const tapeCapture = tapeResult.screenshotPath ?? tapeScreenshotPath;
+            const comparison = await (0, loadCheck_1.comparePlaytestFrames)(idleCapture, tapeCapture);
+            if (!comparison.passed) {
+                (0, messages_1.printErrorWithHelp)(`playtest_smoke_check_not_interactive: The validator completed all ${playtestTape.events.length} tape actions `
+                    + `without a crash, but the result looked the same as running the game for ${playtestTape.durationMs} ms without input.`, [
+                    `Idle screenshot: ${idleCapture}`,
+                    `Tape screenshot: ${tapeCapture}`,
+                    'Make sure the tape performs the core gameplay action and produces a visible response.',
+                ], { command: 'project check' });
+                process.exitCode = 1;
+                return;
             }
+            console.log(`[check] Playtest smoke check passed for ${currentUsername}/${appName}.`);
+            console.log(`[check] ${playtestTape.events.length} tape actions completed without a crash and produced a visible response.`);
+            console.log(`[check] Idle: ${idleCapture}`);
+            console.log(`[check] Tape: ${tapeCapture}`);
             return;
         }
         const result = await runCheck({ screenshotPath });