@playdrop/playdrop-cli 0.15.6 → 0.15.9

package/dist/commands/worker.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WORKER_TASK_WORKSPACE_RETENTION = exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = exports.WORKER_SESSION_EXPIRED_MESSAGE = exports.runLoggedProcess = exports.readEnvBoolean = exports.readCodexSandboxMode = exports.readCodexRolloutTokenUsageForThread = exports.extractCodexTokensUsed = exports.extractCodexThreadId = exports.extractClaudeSessionId = exports.extractCodexRolloutTokenUsage = exports.extractAgentTokenUsage = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = exports.DEFAULT_CODEX_TIMEOUT_MS = exports.buildWorkerChildEnv = exports.buildPlaywrightMcpCommand = exports.buildCodexExecArgs = exports.buildCleanRoomChildEnv = exports.buildClaudePermissionSettings = exports.buildClaudeExecArgs = exports.assertWorkerTokenUsageWithinCap = void 0;
 exports.usesCreatorRecovery = usesCreatorRecovery;
+exports.buildDeterministicReleaseSmokeArtifact = buildDeterministicReleaseSmokeArtifact;
 exports.buildCreatorRecoveryPrompt = buildCreatorRecoveryPrompt;
 exports.buildGameEvalRetryPrompt = buildGameEvalRetryPrompt;
 exports.resolveInitialCreatorProgress = resolveInitialCreatorProgress;
@@ -17,6 +18,7 @@ exports.claimBackoffDelayMs = claimBackoffDelayMs;
 exports.resolveWorkerHomeDir = resolveWorkerHomeDir;
 exports.pruneWorkerTaskWorkspaces = pruneWorkerTaskWorkspaces;
 exports.prepareClaimedTaskWorkspace = prepareClaimedTaskWorkspace;
+exports.buildWorkerTaskContextV2 = buildWorkerTaskContextV2;
 exports.resolveWorkerInstrumentSurface = resolveWorkerInstrumentSurface;
 exports.hasAgentTaskUploadedArtifact = hasAgentTaskUploadedArtifact;
 exports.appendWorkerTranscriptChunks = appendWorkerTranscriptChunks;
@@ -111,7 +113,6 @@ const commandContext_1 = require("../commandContext");
 const config_1 = require("../config");
 const messages_1 = require("../messages");
 const output_1 = require("../output");
-const recorderRelease_1 = require("../recorderRelease");
 const shellProbe_1 = require("../shellProbe");
 const review_1 = require("./review");
 const upload_1 = require("./upload");
@@ -152,7 +153,7 @@ const FAIL_REPORT_RETRY_DELAY_MS = 2000;
 const WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE = 100;
 const SLACK_API_BASE_URL = 'https://slack.com/api';
 const WORKER_WRAPPER_CONTRACT_VERSION = 3;
-const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'STATIC_GAME', 'REMIX_GAME', 'GAME_UPDATE', 'GAME_REVIEW', 'GAME_EVAL'];
+const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'STATIC_GAME', 'REMIX_GAME', 'GAME_UPDATE', 'GAME_REVIEW', 'GAME_EVAL', 'RELEASE_SMOKE'];
 const GAME_CREATION_TASK_KINDS = new Set(['NEW_GAME', 'STATIC_GAME', 'REMIX_GAME', 'GAME_UPDATE']);
 const AGENT_MANAGED_UPLOAD_TASK_KINDS = new Set(['NEW_GAME', 'REMIX_GAME', 'GAME_UPDATE']);
 const requireFromWorker = (0, node_module_1.createRequire)(__filename);
@@ -168,6 +169,14 @@ const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 function usesCreatorRecovery(kind) {
     return GAME_CREATION_TASK_KINDS.has(kind);
 }
+function buildDeterministicReleaseSmokeArtifact() {
+    const content = Buffer.from(types_1.RELEASE_SMOKE_HTML, 'utf8');
+    return {
+        fileName: types_1.RELEASE_SMOKE_FILE_NAME,
+        content,
+        sha256: (0, node_crypto_1.createHash)('sha256').update(content).digest('hex'),
+    };
+}
 function buildCreatorRecoveryPrompt(input) {
     const prompt = input.prompt.trim();
     if (!prompt) {
@@ -610,7 +619,7 @@ function buildWorkerTaskContext(input) {
     }
     const metadata = playdrop;
     const kind = metadata.kind;
-    if (kind !== 'NEW_GAME' && kind !== 'STATIC_GAME' && kind !== 'REMIX_GAME' && kind !== 'GAME_UPDATE' && kind !== 'GAME_REVIEW' && kind !== 'GAME_EVAL') {
+    if (kind !== 'NEW_GAME' && kind !== 'STATIC_GAME' && kind !== 'REMIX_GAME' && kind !== 'GAME_UPDATE' && kind !== 'GAME_REVIEW' && kind !== 'GAME_EVAL' && kind !== 'RELEASE_SMOKE') {
         throw new Error('agent_task_context_kind_missing');
     }
     const creatorUsername = typeof metadata.creatorUsername === 'string'
@@ -3004,45 +3013,6 @@ function collectWorkerInfrastructureFailures() {
     catch (error) {
         failures.push(errorCode(error));
     }
-    if (node_process_1.default.platform !== 'darwin') {
-        return failures;
-    }
-    if (node_process_1.default.arch !== recorderRelease_1.MAC_WORKER_RECORDER_RELEASE.architecture) {
-        failures.push('worker_preflight_recorder_architecture_unsupported');
-        return failures;
-    }
-    if (!workerCommandExists('ffmpeg')) {
-        failures.push('worker_preflight_ffmpeg_missing');
-    }
-    if (!workerCommandExists('ffprobe')) {
-        failures.push('worker_preflight_ffprobe_missing');
-    }
-    const guiSession = (0, shellProbe_1.runShell)('/bin/launchctl print "gui/$(/usr/bin/id -u)"');
-    if (guiSession.exitCode !== 0) {
-        failures.push('worker_preflight_gui_session_missing');
-    }
-    const recorderPath = (0, recorderRelease_1.resolveMacWorkerRecorderPath)();
-    if (!(0, node_fs_1.existsSync)(recorderPath)) {
-        failures.push('worker_preflight_recorder_missing');
-        return failures;
-    }
-    const recorderStat = (0, node_fs_1.statSync)(recorderPath);
-    if (!recorderStat.isFile() || (recorderStat.mode & 0o111) === 0) {
-        failures.push('worker_preflight_recorder_not_executable');
-        return failures;
-    }
-    const installedSha256 = (0, recorderRelease_1.recorderSha256)((0, node_fs_1.readFileSync)(recorderPath));
-    if (installedSha256 !== recorderRelease_1.MAC_WORKER_RECORDER_RELEASE.sha256) {
-        failures.push('worker_preflight_recorder_hash_mismatch');
-        return failures;
-    }
-    const permission = (0, node_child_process_1.spawnSync)(recorderPath, ['--check-permission'], {
-        encoding: 'utf8',
-        timeout: 10000,
-    });
-    if (permission.status !== 0) {
-        failures.push('worker_preflight_screen_recording_permission_missing');
-    }
     return failures;
 }
 function describeWorkerPreflightReason(reason) {
@@ -4218,20 +4188,6 @@ async function startWorker(options = {}) {
         try {
             await removeStaleAgentRunCredentials();
             const startupFailures = [];
-            if (node_process_1.default.platform === 'darwin') {
-                try {
-                    const recorder = await (0, recorderRelease_1.ensureMacWorkerRecorderInstalled)();
-                    if (recorder.downloaded) {
-                        console.log(`Installed PlayDrop macOS recorder ${recorderRelease_1.MAC_WORKER_RECORDER_RELEASE.version} at ${recorder.path}.`);
-                    }
-                }
-                catch (error) {
-                    startupFailures.push(`worker_preflight_recorder_download_failed:${errorMessage(error)}`);
-                }
-            }
-            else if (node_process_1.default.platform === 'win32') {
-                console.warn('Native listing recording is not available on Windows yet.');
-            }
             const local = collectWorkerLocalStatus();
             startupFailures.push(...local.degradedReasons);
             if (startupFailures.length > 0 || !local.ready || !local.capabilities || !local.playwright?.chromiumInstalled) {
@@ -4548,6 +4504,55 @@ async function startWorker(options = {}) {
                             })
                             : null;
                     availableSkillPaths = listPluginSkillPaths(assignmentPluginRoot);
+                    if (task.kind === 'RELEASE_SMOKE') {
+                        if (!assignment.plugin || !assignmentPluginRoot) {
+                            throw new Error('release_smoke_bundle_missing');
+                        }
+                        const artifact = buildDeterministicReleaseSmokeArtifact();
+                        const artifactPath = node_path_1.default.join(agentWorkspaceDir, artifact.fileName);
+                        await (0, promises_1.writeFile)(artifactPath, artifact.content);
+                        const storedArtifact = (0, node_fs_1.readFileSync)(artifactPath);
+                        if ((0, node_crypto_1.createHash)('sha256').update(storedArtifact).digest('hex') !== artifact.sha256) {
+                            throw new Error('release_smoke_workspace_verification_failed');
+                        }
+                        if (!envConfig.cdnBase) {
+                            throw new Error('release_smoke_publish_cdn_base_missing');
+                        }
+                        const taskClient = (0, apiClient_1.createCliApiClient)({
+                            baseUrl: envConfig.apiBase,
+                            token,
+                            onBehalfCreatorUsername: taskContext.creatorUsername,
+                            agentTaskToken: assignment.task.token,
+                            agentTaskId: task.id,
+                            agentTaskAttempt: taskContext.attempt,
+                        });
+                        const published = await (0, upload_1.publishStaticHtmlProject)({
+                            client: taskClient,
+                            taskId: task.id,
+                            taskToken: assignment.task.token,
+                            projectDir: agentWorkspaceDir,
+                            creatorUsername: taskContext.creatorUsername,
+                            primarySurface: 'DESKTOP',
+                            apiBase: envConfig.apiBase,
+                            webBase: envConfig.webBase ?? null,
+                            cdnBase: envConfig.cdnBase,
+                            devRouterPort: devPort,
+                            token,
+                            user: me.user,
+                            skipReview: true,
+                        });
+                        await client.workerCompleteReleaseSmoke(task.id, {
+                            workerKey,
+                            leaseToken,
+                            appId: published.appId,
+                            appVersionId: published.appVersionId,
+                            sourceSha256: published.sourceHash,
+                            runtimeSha256: published.runtimeHash,
+                        });
+                        retainWorkspace = false;
+                        console.log(`Worker release smoke ${task.id} completed without an AI agent.`);
+                        return;
+                    }
                     if (cleanRoom) {
                         const playdropMetadata = assignment.task.metadata.playdrop;
                         const postAgentAction = playdropMetadata && typeof playdropMetadata === 'object' && !Array.isArray(playdropMetadata)
@@ -5538,6 +5543,9 @@ async function uploadTask(options = {}) {
     if (taskContext.kind === 'GAME_REVIEW' || taskContext.kind === 'GAME_EVAL') {
         throw new Error('task_upload_not_allowed_for_game_review');
     }
+    if (taskContext.kind === 'RELEASE_SMOKE') {
+        throw new Error('task_upload_not_allowed_for_release_smoke');
+    }
     const uploadKind = taskContext.kind;
     const workspaceDir = resolveTaskWorkspaceDir();
     if (options.preflightOnly) {
@@ -5567,7 +5575,7 @@ async function uploadTask(options = {}) {
         for (const warning of result.warnings) {
             console.error(`Preflight warning: ${warning}`);
         }
-        (0, output_1.printSuccess)(`Task upload preflight passed for ${result.creatorUsername}/${result.appName}. Final capture can start.`);
+        (0, output_1.printSuccess)(`Task upload preflight passed for ${result.creatorUsername}/${result.appName}. Upload can start.`);
         return;
     }
     if ((0, node_fs_1.existsSync)(workerTaskUploadResultPath(workspaceDir))) {

package/dist/index.js

@@ -273,7 +273,7 @@ task
 task
     .command('upload')
     .description('Upload the active agent task project as a private draft')
-    .option('--preflight-only', 'Run non-mutating upload checks before final capture')
+    .option('--preflight-only', 'Run non-mutating checks without uploading')
     .option('--env <env>', 'Environment override')
     .action(async (opts) => {
     await (0, worker_1.uploadTask)(opts);

package/dist/listingPreflight.d.ts

@@ -1,35 +1,12 @@
-import type { RecordAppUploadMediaCaptureRequest } from '@playdrop/types';
-import type { AppTask } from './catalogue';
-export type ListingMediaFile = {
-    fileKey: string;
-    sha256: string;
-};
 export type WorkerUploadPreflightContext = {
     kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE';
     target: 'FIRST_PARTY' | 'PERSONAL';
     creatorUsername: string;
     creatorRequest: string;
+    outputVersion?: string;
     tweaks?: {
         id: string;
         values: Record<string, string | number | boolean>;
     };
 };
-export declare function readMediaCaptureProof(input: {
-    task: AppTask;
-    preparedSessionFiles: ListingMediaFile[];
-    expectedRuntimeBundleHash?: string;
-}): RecordAppUploadMediaCaptureRequest;
 export declare function readWorkerUploadPreflightContext(projectDir: string): WorkerUploadPreflightContext | null;
-export declare function assertAgentGameHeroListingPreflight(task: AppTask): void;
-export declare function assertAgentGameIconListingPreflight(task: AppTask): void;
-export declare function assertAgentGameVideoListingPreflight(task: AppTask): void;
-export declare function assertAgentGamePreviewListingPreflight(task: AppTask): void;
-export declare function assertAgentGameScreenshotListingPreflight(task: AppTask): void;
-export declare function assertAgentGameCaptureReportPreflight(task: AppTask, options: {
-    requireCaptureReport: boolean;
-    expectedRuntimeBundleHash?: string;
-}): void;
-export declare function assertAgentGameListingPreflight(task: AppTask, options: {
-    requireCaptureReport: boolean;
-}): void;
-export declare function assertProjectListingPreflight(task: AppTask): void;

package/dist/listingPreflight.js

@@ -1,253 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readMediaCaptureProof = readMediaCaptureProof;
 exports.readWorkerUploadPreflightContext = readWorkerUploadPreflightContext;
-exports.assertAgentGameHeroListingPreflight = assertAgentGameHeroListingPreflight;
-exports.assertAgentGameIconListingPreflight = assertAgentGameIconListingPreflight;
-exports.assertAgentGameVideoListingPreflight = assertAgentGameVideoListingPreflight;
-exports.assertAgentGamePreviewListingPreflight = assertAgentGamePreviewListingPreflight;
-exports.assertAgentGameScreenshotListingPreflight = assertAgentGameScreenshotListingPreflight;
-exports.assertAgentGameCaptureReportPreflight = assertAgentGameCaptureReportPreflight;
-exports.assertAgentGameListingPreflight = assertAgentGameListingPreflight;
-exports.assertProjectListingPreflight = assertProjectListingPreflight;
-const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const MIN_HERO_PORTRAIT_WIDTH = 512;
-const MIN_HERO_PORTRAIT_HEIGHT = 768;
-const MIN_HERO_LANDSCAPE_WIDTH = 768;
-const MIN_HERO_LANDSCAPE_HEIGHT = 432;
-function readPngDimensions(filePath, errorCode = 'agent_task_listing_hero_art_invalid') {
-    const buffer = (0, node_fs_1.readFileSync)(filePath);
-    if (buffer.length < 24) {
-        throw new Error(`${errorCode}: ${filePath} is too small to be a valid PNG.`);
-    }
-    const isPng = (buffer[0] === 0x89
-        && buffer[1] === 0x50
-        && buffer[2] === 0x4e
-        && buffer[3] === 0x47
-        && buffer[4] === 0x0d
-        && buffer[5] === 0x0a
-        && buffer[6] === 0x1a
-        && buffer[7] === 0x0a);
-    if (!isPng || buffer.toString('ascii', 12, 16) !== 'IHDR') {
-        throw new Error(`${errorCode}: ${filePath} must be a PNG with an IHDR header.`);
-    }
-    const width = buffer.readUInt32BE(16);
-    const height = buffer.readUInt32BE(20);
-    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-        throw new Error(`${errorCode}: ${filePath} has invalid PNG dimensions.`);
-    }
-    return { width, height };
-}
-function assertListingIcon(task, required = false) {
-    const iconPath = task.listing?.iconPath;
-    if (!iconPath) {
-        if (required) {
-            throw new Error('agent_task_listing_icon_missing: agent game listings must include a dedicated square PNG through listing.icon.');
-        }
-        return;
-    }
-    const icon = readPngDimensions(iconPath, 'listing_icon_invalid');
-    if (icon.width !== icon.height) {
-        throw new Error(`listing_icon_not_square: listing.icon is ${icon.width}x${icon.height}; app icons must use a 1:1 aspect ratio.`);
-    }
-}
-function readCatalogueApp(task) {
-    let data;
-    try {
-        data = JSON.parse((0, node_fs_1.readFileSync)(task.catalogueAbsolutePath, 'utf8'));
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`agent_task_catalogue_invalid_json: ${task.cataloguePath} must be valid JSON. ${reason}`);
-    }
-    const apps = Array.isArray(data?.apps) ? data.apps : [];
-    const app = apps.find((entry) => entry && typeof entry === 'object' && entry.name === task.name);
-    if (!app || typeof app !== 'object') {
-        throw new Error(`agent_task_catalogue_app_missing: ${task.cataloguePath} must contain apps[] entry "${task.name}".`);
-    }
-    return app;
-}
-function assertHeroListingKeys(task) {
-    const listing = readCatalogueApp(task).listing;
-    if (!listing || typeof listing !== 'object' || Array.isArray(listing)) {
-        return;
-    }
-    const hasLegacyPortrait = typeof listing.heroPortraitPath === 'string' && listing.heroPortraitPath.trim().length > 0;
-    const hasLegacyLandscape = typeof listing.heroLandscapePath === 'string' && listing.heroLandscapePath.trim().length > 0;
-    if (hasLegacyPortrait || hasLegacyLandscape) {
-        throw new Error('agent_task_listing_hero_art_legacy_keys: new game tasks must reference hero art through listing.heroPortrait and listing.heroLandscape, not listing.heroPortraitPath or listing.heroLandscapePath.');
-    }
-}
-function assertHeroListingPath(task, filePath, field) {
-    const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(task.projectDir), (0, node_path_1.resolve)(filePath)).replace(/\\/g, '/');
-    if (relativePath === '' || relativePath === '..' || relativePath.startsWith('../') || relativePath.startsWith('/')) {
-        throw new Error(`agent_task_listing_hero_art_path_invalid: ${field} must point to a PNG inside the project under assets/marketing/playdrop/.`);
-    }
-    if (!relativePath.startsWith('assets/marketing/playdrop/') || (0, node_path_1.extname)(relativePath).toLowerCase() !== '.png') {
-        throw new Error(`agent_task_listing_hero_art_path_invalid: ${field} must point to a PNG under assets/marketing/playdrop/.`);
-    }
-}
-function assertHeroListingArt(task) {
-    const heroPortraitPath = task.listing?.heroPortraitPath;
-    const heroLandscapePath = task.listing?.heroLandscapePath;
-    if (!heroPortraitPath || !heroLandscapePath) {
-        throw new Error('agent_task_listing_hero_art_missing: new game tasks must include listing.heroPortrait and listing.heroLandscape PNG assets.');
-    }
-    assertHeroListingKeys(task);
-    assertHeroListingPath(task, heroPortraitPath, 'listing.heroPortrait');
-    assertHeroListingPath(task, heroLandscapePath, 'listing.heroLandscape');
-    const portrait = readPngDimensions(heroPortraitPath);
-    if (portrait.width < MIN_HERO_PORTRAIT_WIDTH || portrait.height < MIN_HERO_PORTRAIT_HEIGHT || portrait.height <= portrait.width) {
-        throw new Error(`agent_task_listing_hero_art_invalid: listing.heroPortrait must be a portrait PNG at least ${MIN_HERO_PORTRAIT_WIDTH}x${MIN_HERO_PORTRAIT_HEIGHT}.`);
-    }
-    const landscape = readPngDimensions(heroLandscapePath);
-    if (landscape.width < MIN_HERO_LANDSCAPE_WIDTH || landscape.height < MIN_HERO_LANDSCAPE_HEIGHT || landscape.width <= landscape.height) {
-        throw new Error(`agent_task_listing_hero_art_invalid: listing.heroLandscape must be a landscape PNG at least ${MIN_HERO_LANDSCAPE_WIDTH}x${MIN_HERO_LANDSCAPE_HEIGHT}.`);
-    }
-}
-function assertScreenshotPath(task, filePath, field) {
-    const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(task.projectDir), (0, node_path_1.resolve)(filePath)).replace(/\\/g, '/');
-    const requiredPrefix = field === 'listing.screenshotsPortrait'
-        ? 'assets/marketing/playdrop/screenshots/portrait/'
-        : 'assets/marketing/playdrop/screenshots/landscape/';
-    if (relativePath === '' || relativePath === '..' || relativePath.startsWith('../') || relativePath.startsWith('/')) {
-        throw new Error(`agent_task_listing_screenshots_path_invalid: ${field} entries must point to PNG files inside the project under ${requiredPrefix}.`);
-    }
-    if (!relativePath.startsWith(requiredPrefix) || (0, node_path_1.extname)(relativePath).toLowerCase() !== '.png') {
-        throw new Error(`agent_task_listing_screenshots_path_invalid: ${field} entries must point to PNG files under ${requiredPrefix}.`);
-    }
-}
-function assertListingScreenshots(task) {
-    const portraitPaths = task.listing?.screenshotPortraitPaths ?? [];
-    const landscapePaths = task.listing?.screenshotLandscapePaths ?? [];
-    for (const filePath of portraitPaths) {
-        assertScreenshotPath(task, filePath, 'listing.screenshotsPortrait');
-        readPngDimensions(filePath);
-    }
-    for (const filePath of landscapePaths) {
-        assertScreenshotPath(task, filePath, 'listing.screenshotsLandscape');
-        readPngDimensions(filePath);
-    }
-}
-function assertListingGameplayVideo(task) {
-    const videoCount = (task.listing?.videoPortraitPaths?.length ?? 0)
-        + (task.listing?.videoLandscapePaths?.length ?? 0);
-    if (videoCount === 0) {
-        throw new Error('agent_task_listing_video_missing: agent game listings must include at least one real gameplay video through listing.videosPortrait or listing.videosLandscape.');
-    }
-}
-function assertListingPreviewMode(task) {
-    if (task.previewable !== true) {
-        throw new Error('agent_task_listing_preview_missing: agent game listings must set previewable: true and implement the real gameplay preview contract before capture.');
-    }
-}
-function isSha256Hex(value) {
-    return typeof value === 'string' && /^[a-f0-9]{64}$/i.test(value.trim());
-}
-function isCaptureVideoFileKey(fileKey) {
-    return fileKey.startsWith('videosPortrait:')
-        || fileKey.startsWith('videosLandscape:');
-}
-function readMediaCaptureProof(input) {
-    const reportPath = input.task.listing?.captureReportPath;
-    if (!reportPath) {
-        throw new Error(`agent_task_media_capture_report_missing: ${input.task.name} must include listing.captureReport from "playdrop project capture".`);
-    }
-    let report;
-    try {
-        report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} must be valid JSON. ${reason}`);
-    }
-    const binding = report?.binding;
-    if (!binding || typeof binding !== 'object' || Array.isArray(binding)) {
-        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} is missing binding.`);
-    }
-    if (report.appName !== input.task.name) {
-        throw new Error(`agent_task_media_capture_wrong_app: listing.captureReport is for ${String(report.appName || 'unknown')}, not ${input.task.name}; rerun "playdrop project capture".`);
-    }
-    if (binding.pixelValidation !== 'passed') {
-        throw new Error(`agent_task_media_capture_pixels_unvalidated: ${reportPath} must come from a capture that passed wrong-game, black-frame, and motion checks.`);
-    }
-    if (input.expectedRuntimeBundleHash) {
-        const capturedRuntimeBundleHash = typeof binding.runtimeBundleHash === 'string'
-            ? binding.runtimeBundleHash.trim().toLowerCase()
-            : '';
-        if (!isSha256Hex(capturedRuntimeBundleHash)) {
-            throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.runtimeBundleHash must be a SHA-256 hash.`);
-        }
-        if (capturedRuntimeBundleHash !== input.expectedRuntimeBundleHash.trim().toLowerCase()) {
-            throw new Error(`agent_task_media_capture_runtime_changed: ${input.task.name} changed after listing.captureReport was recorded; rerun "playdrop project capture".`);
-        }
-    }
-    const rawArtifactHashes = binding.artifactHashes;
-    if (!rawArtifactHashes || typeof rawArtifactHashes !== 'object' || Array.isArray(rawArtifactHashes)) {
-        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.artifactHashes must be an object.`);
-    }
-    const captureArtifactHashEntries = Object.entries(rawArtifactHashes)
-        .filter(([artifactKey]) => (0, node_path_1.extname)(artifactKey).toLowerCase() === '.mp4')
-        .map(([, value]) => typeof value === 'string' ? value.trim().toLowerCase() : '')
-        .filter((value) => isSha256Hex(value));
-    const captureArtifactHashes = new Set(captureArtifactHashEntries);
-    if (captureArtifactHashEntries.length === 0) {
-        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.artifactHashes must include at least one MP4 gameplay video.`);
-    }
-    const captureArtifactHashCounts = new Map();
-    for (const hash of captureArtifactHashEntries) {
-        captureArtifactHashCounts.set(hash, (captureArtifactHashCounts.get(hash) ?? 0) + 1);
-    }
-    const mediaFiles = input.preparedSessionFiles.filter((file) => isCaptureVideoFileKey(file.fileKey));
-    if (mediaFiles.length === 0) {
-        throw new Error(`agent_task_media_capture_artifacts_missing: ${input.task.name} must upload recorder gameplay video in listing.videos*.`);
-    }
-    const uploadedMediaHashCounts = new Map();
-    for (const file of mediaFiles) {
-        uploadedMediaHashCounts.set(file.sha256, (uploadedMediaHashCounts.get(file.sha256) ?? 0) + 1);
-    }
-    const missingUploadedCaptureArtifacts = [...captureArtifactHashCounts.entries()]
-        .filter(([hash, expectedCount]) => (uploadedMediaHashCounts.get(hash) ?? 0) < expectedCount);
-    if (missingUploadedCaptureArtifacts.length > 0) {
-        throw new Error(`agent_task_media_capture_artifact_missing_from_listing: ${input.task.name} must list every recorder gameplay video from listing.captureReport in catalogue.json.`);
-    }
-    let hasVideo = false;
-    const artifactHashes = {};
-    for (const file of mediaFiles) {
-        if (!captureArtifactHashes.has(file.sha256)) {
-            throw new Error(`agent_task_media_capture_artifact_mismatch: ${file.fileKey} was not produced by listing.captureReport for ${input.task.name}.`);
-        }
-        hasVideo = hasVideo || file.fileKey.startsWith('videos');
-        artifactHashes[file.fileKey] = file.sha256;
-    }
-    if (!hasVideo) {
-        throw new Error(`agent_task_media_capture_artifacts_missing: ${input.task.name} must upload at least one recorder gameplay video.`);
-    }
-    const capturedSurfaces = Array.isArray(binding.capturedSurfaces)
-        ? Array.from(new Set(binding.capturedSurfaces
-            .map((surface) => typeof surface === 'string' ? surface.trim().toUpperCase() : '')
-            .filter((surface) => input.task.surfaceTargets.includes(surface))))
-        : [];
-    const capturedSurfaceSet = new Set(capturedSurfaces);
-    const missingSurfaces = input.task.surfaceTargets.filter((surface) => !capturedSurfaceSet.has(surface));
-    if (missingSurfaces.length > 0) {
-        throw new Error(`agent_task_media_capture_surface_missing: listing.captureReport did not capture ${missingSurfaces.join(', ')} for ${input.task.name}.`);
-    }
-    return { artifactHashes, capturedSurfaces };
-}
-function listingMediaFiles(task) {
-    const entries = [];
-    task.listing?.screenshotPortraitPaths.forEach((path, index) => entries.push([`screenshotsPortrait:${index}`, path]));
-    task.listing?.screenshotLandscapePaths.forEach((path, index) => entries.push([`screenshotsLandscape:${index}`, path]));
-    task.listing?.videoPortraitPaths.forEach((path, index) => entries.push([`videosPortrait:${index}`, path]));
-    task.listing?.videoLandscapePaths.forEach((path, index) => entries.push([`videosLandscape:${index}`, path]));
-    return entries.map(([fileKey, path]) => ({
-        fileKey,
-        sha256: (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(path)).digest('hex'),
-    }));
-}
 function findWorkerTaskContextPath(projectDir) {
     let current = (0, node_path_1.resolve)(projectDir);
     while (true) {
@@ -303,6 +58,9 @@ function readWorkerUploadPreflightContext(projectDir) {
             target,
             creatorUsername: typeof playdrop.creatorUsername === 'string' ? playdrop.creatorUsername.trim() : '',
             creatorRequest: typeof request.prompt === 'string' ? request.prompt.trim() : '',
+            ...(typeof playdrop.output?.version === 'string' && playdrop.output.version.trim()
+                ? { outputVersion: playdrop.output.version.trim() }
+                : {}),
             ...(playdrop.tweaks
                 && typeof playdrop.tweaks === 'object'
                 && !Array.isArray(playdrop.tweaks)
@@ -338,46 +96,3 @@ function readWorkerUploadPreflightContext(projectDir) {
             : {}),
     };
 }
-function assertAgentGameHeroListingPreflight(task) {
-    assertHeroListingArt(task);
-}
-function assertAgentGameIconListingPreflight(task) {
-    assertListingIcon(task, true);
-}
-function assertAgentGameVideoListingPreflight(task) {
-    assertListingGameplayVideo(task);
-}
-function assertAgentGamePreviewListingPreflight(task) {
-    assertListingPreviewMode(task);
-}
-function assertAgentGameScreenshotListingPreflight(task) {
-    assertListingScreenshots(task);
-}
-function assertAgentGameCaptureReportPreflight(task, options) {
-    if (options.requireCaptureReport || task.listing?.captureReportPath) {
-        readMediaCaptureProof({
-            task,
-            preparedSessionFiles: listingMediaFiles(task),
-            expectedRuntimeBundleHash: options.expectedRuntimeBundleHash,
-        });
-    }
-}
-function assertAgentGameListingPreflight(task, options) {
-    assertAgentGameIconListingPreflight(task);
-    assertAgentGameHeroListingPreflight(task);
-    assertAgentGamePreviewListingPreflight(task);
-    assertAgentGameVideoListingPreflight(task);
-    assertAgentGameScreenshotListingPreflight(task);
-    assertAgentGameCaptureReportPreflight(task, options);
-}
-function assertProjectListingPreflight(task) {
-    assertListingIcon(task);
-    const context = readWorkerUploadPreflightContext(task.projectDir);
-    if (context?.kind === 'NEW_GAME' || context?.kind === 'REMIX_GAME') {
-        assertAgentGameListingPreflight(task, { requireCaptureReport: context.target === 'FIRST_PARTY' });
-        return;
-    }
-    if (task.listing?.captureReportPath) {
-        readMediaCaptureProof({ task, preparedSessionFiles: listingMediaFiles(task) });
-    }
-}