@playdrop/playdrop-cli 0.10.21 → 0.11.4

package/dist/commands/upload.js

@@ -50,6 +50,8 @@ const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const upload_content_1 = require("./upload-content");
 const appUrls_1 = require("../appUrls");
+const launchCheck_1 = require("../apps/launchCheck");
+const devRuntimeAssets_1 = require("./devRuntimeAssets");
 const upload_graph_1 = require("./upload-graph");
 function normalizeSavedItemKinds(kinds) {
     return [...new Set(Array.isArray(kinds) ? kinds : [])].sort();
@@ -1250,9 +1252,6 @@ function appTaskSatisfiesPlaydropAssetRequirement(task, requirement) {
     });
     return hasFirstPartyPack || hasFirstPartyAsset || task.ownedAssets.length > 0;
 }
-function appTaskHasRequiredNewGameAssets(task) {
-    return task.uses.packs.length > 0 || task.uses.assets.length > 0 || task.ownedAssets.length > 0;
-}
 function isUnsafeDirectPlaydropAiImageAsset(detail, parsedRevision) {
     const asset = detail?.asset;
     if (!asset || asset.category !== 'IMAGE') {
@@ -1285,7 +1284,7 @@ async function assertNewGameDirectPlaydropAssetsAreRuntimeSafe(input) {
         }
     }
     if (unsafeRefs.length > 0) {
-        throw new Error(`agent_task_playdrop_direct_ai_image_asset_unsafe: direct PlayDrop AI JPEG image assets cannot be used as new-game runtime sprites because their backgrounds are baked into the image. Use a PlayDrop asset pack or create owned PNG assets through the PlayDrop plugin asset-extraction-2d workflow instead. Unsafe refs: ${unsafeRefs.join(', ')}`);
+        throw new Error(`agent_task_playdrop_direct_ai_image_asset_unsafe: direct PlayDrop AI JPEG image assets cannot be used as new-game runtime sprites because their backgrounds are baked into the image. Use a PlayDrop asset pack or create clean owned PNG assets through the PlayDrop make-assets workflow instead. Unsafe refs: ${unsafeRefs.join(', ')}`);
     }
 }
 function isOwnedRuntimeImageAsset(task, ownedAsset) {
@@ -1605,7 +1604,7 @@ async function assertNewGameOwnedRuntimeImageAssetsAreClean(task) {
         }
     }
     if (unsafeAssets.length > 0) {
-        throw new Error(`agent_task_owned_image_asset_checkerboard_background: owned runtime image assets must not contain baked transparency checkerboard, matte-color, or preview backgrounds. Recreate the asset through the PlayDrop plugin asset-extraction-2d workflow, use a cleaner PlayDrop asset, or use the image as non-runtime listing art only. Unsafe owned assets: ${unsafeAssets.join(', ')}`);
+        throw new Error(`agent_task_owned_image_asset_checkerboard_background: owned runtime image assets must not contain baked transparency checkerboard, matte-color, or preview backgrounds. Recreate the asset through the PlayDrop make-assets workflow, use a cleaner PlayDrop asset, or use the image as non-runtime listing art only. Unsafe owned assets: ${unsafeAssets.join(', ')}`);
     }
 }
 const RUNTIME_SOURCE_EXTENSIONS = new Set([
@@ -1673,6 +1672,95 @@ function hasDisallowedGameplayAssetFallback(source) {
     const executableSource = stripRuntimeSourceCommentsAndStrings(source);
     return /\bdrawFallback[A-Za-z0-9_]*\b|\bfallback(?:Image|Sprite|Asset|Draw|Visual|Character|Obstacle|Collectible|Prop|Enemy|Item|Piñata|Pinata|Candy)?\b|\bplaceholder(?:Image|Sprite|Asset|Draw|Visual|Character|Obstacle|Collectible|Prop|Enemy|Item)?\b|img\.onerror\s*=\s*(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>\s*(?:\{[^}]*\bresolve\s*\(|\bresolve\s*\(|\{[^}]*\breturn\b)|if\s*\([^)]*!url[^)]*\)\s*\{[^}]*\bresolve\s*\([^}]*\breturn\b|if\s*\([^)]*!url[^)]*\)\s*(?:return|continue|resolve\s*\()/i.test(executableSource);
 }
+function formatRuntimeSourceLocation(runtimeSource, offset) {
+    const location = resolveRuntimeSourceLocation(runtimeSource, offset);
+    if (!location) {
+        return 'unknown source location';
+    }
+    return `${location.path}:${location.line}:${location.column}`;
+}
+function findRuntimeSourcePattern(runtimeSource, pattern) {
+    const match = pattern.exec(runtimeSource.source);
+    if (!match) {
+        return null;
+    }
+    return {
+        match: match[0],
+        location: formatRuntimeSourceLocation(runtimeSource, match.index),
+    };
+}
+function assertNoLaunchCheckConditionalSource(runtimeSource) {
+    const directMarker = findRuntimeSourcePattern(runtimeSource, /\b(?:launchCheck|launch-check|upload-check|previewToken|localDevPort)\b/i);
+    if (directMarker) {
+        throw new Error(`agent_task_launch_check_conditional_disallowed: game source must not branch on PlayDrop validation markers. First match "${directMarker.match}" at ${directMarker.location}.`);
+    }
+    const environmentSniff = findRuntimeSourcePattern(runtimeSource, /(?:document\.referrer|window\.location|\blocation\.(?:href|search|origin)|new\s+URLSearchParams)[\s\S]{0,320}(?:localhost|127\.0\.0\.1|_auth\/creators|\/upload-check\/)|(?:localhost|127\.0\.0\.1|_auth\/creators|\/upload-check\/)[\s\S]{0,320}(?:document\.referrer|window\.location|\blocation\.(?:href|search|origin)|new\s+URLSearchParams)/i);
+    if (environmentSniff) {
+        throw new Error(`agent_task_launch_check_conditional_disallowed: game source must not sniff validation or local route context. First match at ${environmentSniff.location}.`);
+    }
+}
+function hasProceduralAssetStrategy(task) {
+    const strategy = task.design?.assetStrategy;
+    return strategy?.value === 'procedural';
+}
+function hasDeclaredRuntimeAssetDependency(task) {
+    return task.uses.packs.length > 0
+        || task.uses.assets.length > 0
+        || task.ownedAssets.some((ownedAsset) => !isListingOwnedAsset(task, ownedAsset));
+}
+function assertNewGameAssetStrategy(task) {
+    if (hasDeclaredRuntimeAssetDependency(task)) {
+        return;
+    }
+    if (hasProceduralAssetStrategy(task)) {
+        return;
+    }
+    throw new Error('agent_task_asset_strategy_missing: new game tasks must either declare true runtime assets/packs or set design.assetStrategy to { "value": "procedural", "note": "..." } for an honest procedural draft.');
+}
+function isListingOwnedAsset(task, ownedAsset) {
+    const primaryPath = ownedAsset.filePaths?.primary;
+    if (!primaryPath) {
+        return false;
+    }
+    const relativePath = primaryPath.slice((0, node_path_1.resolve)(task.projectDir).length + 1).replace(/\\/g, '/');
+    return relativePath.startsWith('assets/marketing/') || relativePath.startsWith('listing/');
+}
+function isAudioOwnedAsset(ownedAsset) {
+    return ownedAsset.category === 'AUDIO';
+}
+function sourceMentionsRuntimeKey(source, runtimeKey) {
+    return source.includes(runtimeKey);
+}
+function hasRuntimeAssetLoadOrRenderPath(source) {
+    return /\bsdk\.assets\b|\.resolveAppAsset\s*\(|\.listAppAssets\s*\(/.test(source)
+        && /\bnew\s+(?:Image|Audio)\s*\(|createImageBitmap\s*\(|\.src\s*=|\.load(?:Async)?\s*\(|\.drawImage\s*\(|\.add\.image\s*\(|\.load\.image\s*\(|\.textures\.add|\.sound\.add|\.scene\.add\s*\(/i.test(source);
+}
+function assertAudioAssetsAreNonBlocking(task, runtimeSource) {
+    const source = runtimeSource.source;
+    for (const ownedAsset of task.ownedAssets) {
+        if (!isAudioOwnedAsset(ownedAsset)) {
+            continue;
+        }
+        const runtimeKey = ownedAsset.runtimeKey?.trim() ?? '';
+        const name = ownedAsset.name.trim();
+        if (!runtimeKey || (!source.includes(runtimeKey) && !source.includes(name))) {
+            continue;
+        }
+        const lowerRuntimeKey = runtimeKey.toLowerCase();
+        const lowerName = name.toLowerCase();
+        const executableSource = stripRuntimeSourceCommentsAndStrings(source);
+        const fatalAudioPattern = /\bthrow\s+new\s+Error\s*\([^)]*(?:missing|asset|sound|audio|sfx)[^)]*\)|\bthrow\s+new\s+Error\s*\([^)]*\)|Promise\.reject\s*\([^)]*(?:missing|asset|sound|audio|sfx)[^)]*\)/ig;
+        let match;
+        while ((match = fatalAudioPattern.exec(executableSource)) !== null) {
+            const start = Math.max(0, match.index - 800);
+            const end = Math.min(source.length, match.index + 800);
+            const nearby = source.slice(start, end).toLowerCase();
+            if (nearby.includes(lowerRuntimeKey) || nearby.includes(lowerName)) {
+                throw new Error(`agent_task_audio_asset_boot_fatal_disallowed: audio SFX owned asset "${ownedAsset.name}" must not block play when it fails to load; log a console warning and continue.`);
+            }
+        }
+    }
+}
 function hasRuntimeAssetUrlExtensionAssumption(source) {
     return /(?:\.url|\.href|\burl\b)[^;\n]{0,220}(?:\\\.gl(?:b|tf)|\.gl(?:b|tf)|\.endsWith\s*\(\s*['"]\.gl(?:b|tf)['"]\s*\)|\.includes\s*\(\s*['"]\.gl(?:b|tf)['"]\s*\)|\.match\s*\([^)]*\.gl(?:b|tf))/i.test(source);
 }
@@ -1873,15 +1961,64 @@ function assertRequestedPlaydropAssetsAreUsedAtRuntime(input) {
         }
     }
 }
-function assertNewGameDeclaredAssetsAreUsedAtRuntime(task) {
-    const source = readRuntimeSourceText(task.projectDir).source;
+async function assertNewGameDeclaredAssetsAreUsedAtRuntime(input) {
+    const runtimeSource = readRuntimeSourceText(input.task.projectDir);
+    const source = runtimeSource.source;
+    assertNoLaunchCheckConditionalSource(runtimeSource);
+    assertNewGameAssetStrategy(input.task);
+    if (!hasDeclaredRuntimeAssetDependency(input.task)) {
+        return;
+    }
     if (!/\bsdk\.assets\b|\.resolveAppAsset\s*\(|\.listAppAssets\s*\(/.test(source)) {
         throw new Error('agent_task_game_assets_runtime_missing: new game tasks must load declared gameplay assets through sdk.assets at runtime.');
     }
-    if (task.uses.packs.length > 0 && !/\.listAppAssets\s*\(/.test(source)) {
+    if (input.task.uses.packs.length > 0 && !/\.listAppAssets\s*\(/.test(source)) {
         throw new Error('agent_task_game_pack_runtime_missing: new game tasks that declare uses.packs must enumerate pack assets with sdk.assets.listAppAssets().');
     }
-    const hasDirectGameplayAssets = task.ownedAssets.length > 0 || task.uses.assets.length > 0;
+    if (!hasRuntimeAssetLoadOrRenderPath(source)) {
+        throw new Error('agent_task_game_assets_runtime_missing: declared game assets must be loaded and rendered or played at runtime, not only listed in catalogue.json.');
+    }
+    if (input.task.uses.packs.length > 0 && !/\bassetRef\b|\bsourceType\b|\bcontentType\b/i.test(source)) {
+        throw new Error('agent_task_game_pack_runtime_missing: new game tasks that declare uses.packs must select pack assets from the runtime manifest by assetRef/sourceType/contentType before rendering them.');
+    }
+    const manifest = input.task.ownedAssets.length > 0
+        ? await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
+            client: input.client,
+            apiBase: input.apiBase,
+            task: {
+                ...input.task,
+                uses: { assets: [], packs: [] },
+            },
+            creatorUsername: input.creatorUsername,
+            appBaseUrl: `http://127.0.0.1/apps/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent((0, appUrls_1.getAppTypeSlug)(input.task.type ?? 'GAME'))}/${encodeURIComponent(input.task.name)}/`,
+        })
+        : null;
+    const runtimeKeys = new Set((manifest?.response.assets ?? [])
+        .map((asset) => typeof asset.runtimeKey === 'string' ? asset.runtimeKey.trim() : '')
+        .filter(Boolean));
+    for (const ownedAsset of input.task.ownedAssets) {
+        const runtimeKey = ownedAsset.runtimeKey?.trim() ?? '';
+        if (!runtimeKey) {
+            throw new Error(`agent_task_owned_asset_runtime_key_missing: owned asset "${ownedAsset.name}" must declare a runtimeKey.`);
+        }
+        if (!runtimeKeys.has(runtimeKey)) {
+            throw new Error(`agent_task_owned_asset_runtime_manifest_missing: owned asset "${ownedAsset.name}" runtimeKey "${runtimeKey}" was not present in the runtime manifest.`);
+        }
+        if (isListingOwnedAsset(input.task, ownedAsset)) {
+            continue;
+        }
+        if (!sourceMentionsRuntimeKey(source, runtimeKey)) {
+            throw new Error(`agent_task_owned_asset_runtime_key_unused: owned asset "${ownedAsset.name}" runtimeKey "${runtimeKey}" does not appear in runtime source.`);
+        }
+    }
+    for (const dependency of input.task.uses.assets) {
+        const runtimeKey = dependency.runtimeKey?.trim() ?? '';
+        if (runtimeKey && !sourceMentionsRuntimeKey(source, runtimeKey)) {
+            throw new Error(`agent_task_declared_asset_runtime_key_unused: declared asset "${dependency.ref}" runtimeKey "${runtimeKey}" does not appear in runtime source.`);
+        }
+    }
+    assertAudioAssetsAreNonBlocking(input.task, runtimeSource);
+    const hasDirectGameplayAssets = input.task.ownedAssets.some((ownedAsset) => !isListingOwnedAsset(input.task, ownedAsset)) || input.task.uses.assets.length > 0;
     if (hasDirectGameplayAssets && hasDisallowedGameplayAssetFallback(source)) {
         throw new Error('agent_task_game_asset_fallback_disallowed: new game tasks must fail clearly when declared gameplay assets cannot load instead of rendering placeholder or fallback visuals.');
     }
@@ -1909,79 +2046,6 @@ function readPngDimensions(filePath) {
     }
     return { width, height };
 }
-function readPngTextMetadata(filePath) {
-    const buffer = (0, node_fs_1.readFileSync)(filePath);
-    const metadata = {};
-    if (buffer.length < 24) {
-        return metadata;
-    }
-    let offset = 8;
-    while (offset + 12 <= buffer.length) {
-        const length = buffer.readUInt32BE(offset);
-        const dataStart = offset + 8;
-        const dataEnd = dataStart + length;
-        const chunkEnd = dataEnd + 4;
-        if (chunkEnd > buffer.length) {
-            break;
-        }
-        const type = buffer.toString('ascii', offset + 4, offset + 8);
-        if (type === 'tEXt') {
-            const chunkData = buffer.subarray(dataStart, dataEnd);
-            const separatorOffset = chunkData.indexOf(0);
-            if (separatorOffset > 0) {
-                const keyword = chunkData.toString('latin1', 0, separatorOffset).trim();
-                const value = chunkData.toString('latin1', separatorOffset + 1).trim();
-                if (keyword && value) {
-                    metadata[keyword] = value;
-                }
-            }
-        }
-        offset = chunkEnd;
-        if (type === 'IEND') {
-            break;
-        }
-    }
-    return metadata;
-}
-function normalizeHeroPromptText(value) {
-    return value.normalize('NFKC').replace(/\s+/g, ' ').trim().toLowerCase();
-}
-function heroPromptContainsRequiredTitleInstruction(prompt, displayName) {
-    const normalizedPrompt = normalizeHeroPromptText(prompt);
-    const normalizedDisplayName = normalizeHeroPromptText(displayName);
-    if (!normalizedDisplayName || !normalizedPrompt.includes(normalizedDisplayName)) {
-        return false;
-    }
-    const hasTitleLanguage = /\btitle\b|\blogo\b|\bwordmark\b/.test(normalizedPrompt);
-    const hasProminenceLanguage = /\bfront[-\s]?and[-\s]?center\b|\bfront center\b|\bcenter(?:ed)?\b|\bprominent\b|\blarge readable\b/.test(normalizedPrompt);
-    return hasTitleLanguage && hasProminenceLanguage && heroPromptForbidsExtraReadableText(prompt);
-}
-function heroPromptForbidsExtraReadableText(prompt) {
-    const normalizedPrompt = normalizeHeroPromptText(prompt);
-    return /\bno\b[^.]{0,180}\b(?:extra|other|additional)\b[^.]{0,180}\b(?:readable\s+)?(?:text|words|letters|numbers|banners|signs|captions|labels|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
-        || /\bno\b[^.]{0,180}\b(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
-        || /\bno\b[^.]{0,180}\b(?:readable\s+)?(?:text|words|letters|numbers|banners|signs|captions|labels|dates|taglines|subtitles)\b[^.]{0,180}\banywhere\b/i.test(normalizedPrompt)
-        || /\bforbid\b[^.]{0,180}\b(?:all\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
-        || /\b(?:text|word|letter|typography|writing)[-\s]?free\b/i.test(normalizedPrompt)
-        || /\bwithout\b[^.]{0,180}\b(?:any\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
-        || /\b(?:do\s+not|don't|dont|never)\b[^.]{0,180}\b(?:include|add|render|show|place|draw|write)\b[^.]{0,180}\b(?:any\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt)
-        || /\b(?:avoid|exclude|omit|remove)\b[^.]{0,180}\b(?:all\s+|any\s+)?(?:readable\s+)?(?:text|words|letters|numbers|typography|writing|banners|signs|signage|captions|labels|logos|titles|dates|taglines|subtitles)\b/i.test(normalizedPrompt);
-}
-function assertNewGameHeroListingPromptMetadata(input) {
-    const metadata = readPngTextMetadata(input.filePath);
-    const tool = metadata['playdrop:cliOutputTool'] ?? '';
-    const prompt = metadata['playdrop:cliOutputPrompt'] ?? '';
-    const titleTool = metadata['playdrop:listingTitleTool'] ?? '';
-    if (titleTool === 'playdrop compose-listing-title') {
-        throw new Error(`agent_task_listing_hero_art_composed_title_disallowed: ${input.field} must be generated directly by PlayDrop AI with the exact display name "${input.displayName}" integrated front and center, not added afterward by a title overlay script.`);
-    }
-    if (tool !== 'playdrop ai create image --output' || !prompt) {
-        throw new Error(`agent_task_listing_hero_art_metadata_missing: ${input.field} must be produced by "playdrop ai create image --output" or by the staged listing title composition script so PlayDrop can verify listing-art metadata.`);
-    }
-    if (!heroPromptContainsRequiredTitleInstruction(prompt, input.displayName)) {
-        throw new Error(`agent_task_listing_hero_art_title_prompt_missing: ${input.field} must be generated from a prompt containing the exact display name "${input.displayName}" as prominent front-and-center title/logo text and forbidding all extra readable text.`);
-    }
-}
 function readAgentTaskCatalogueApp(task) {
     let data;
     try {
@@ -2020,10 +2084,6 @@ function assertNewGameHeroListingPath(task, filePath, field) {
     }
 }
 function assertNewGameHeroListingArt(task) {
-    const app = readAgentTaskCatalogueApp(task);
-    const displayName = typeof app.displayName === 'string' && app.displayName.trim()
-        ? app.displayName.trim()
-        : task.name;
     const heroPortraitPath = task.listing?.heroPortraitPath;
     const heroLandscapePath = task.listing?.heroLandscapePath;
     if (!heroPortraitPath || !heroLandscapePath) {
@@ -2040,18 +2100,173 @@ function assertNewGameHeroListingArt(task) {
     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}.`);
     }
-    assertNewGameHeroListingPromptMetadata({
-        projectDir: task.projectDir,
-        filePath: heroPortraitPath,
-        field: 'listing.heroPortrait',
-        displayName,
-    });
-    assertNewGameHeroListingPromptMetadata({
-        projectDir: task.projectDir,
-        filePath: heroLandscapePath,
-        field: 'listing.heroLandscape',
-        displayName,
+}
+function assertListingScreenshotPath(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 assertNewGameListingScreenshots(task) {
+    const listing = task.listing;
+    const portraitPaths = listing?.screenshotPortraitPaths ?? [];
+    const landscapePaths = listing?.screenshotLandscapePaths ?? [];
+    if (portraitPaths.length === 0 && landscapePaths.length === 0) {
+        throw new Error('agent_task_listing_screenshots_missing: new game tasks must include listing.screenshotsPortrait and/or listing.screenshotsLandscape PNG captures.');
+    }
+    if (task.surfaceTargets.includes('MOBILE_PORTRAIT') && portraitPaths.length === 0) {
+        throw new Error('agent_task_listing_screenshots_missing: mobile portrait games must include at least one listing.screenshotsPortrait PNG capture.');
+    }
+    if ((task.surfaceTargets.includes('DESKTOP') || task.surfaceTargets.includes('MOBILE_LANDSCAPE')) && landscapePaths.length === 0) {
+        throw new Error('agent_task_listing_screenshots_missing: desktop or landscape games must include at least one listing.screenshotsLandscape PNG capture.');
+    }
+    for (const filePath of portraitPaths) {
+        assertListingScreenshotPath(task, filePath, 'listing.screenshotsPortrait');
+        readPngDimensions(filePath);
+    }
+    for (const filePath of landscapePaths) {
+        assertListingScreenshotPath(task, filePath, 'listing.screenshotsLandscape');
+        readPngDimensions(filePath);
+    }
+}
+function readPlaytestEvidenceManifest(task) {
+    const manifestPath = (0, node_path_1.join)(task.projectDir, 'playtest-evidence.json');
+    if (!(0, node_fs_1.existsSync)(manifestPath)) {
+        throw new Error(formatMissingPlaytestEvidenceManifestError('new game tasks must include playtest-evidence.json before upload.'));
+    }
+    try {
+        const value = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error('manifest must be a JSON object');
+        }
+        return value;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(formatPlaytestEvidenceManifestError(`playtest-evidence.json must be valid JSON. ${reason}`));
+    }
+}
+const PLAYTEST_EVIDENCE_MANIFEST_HELP = 'Expected shape: {"version":1,"entries":[{"environment":"local","url":"http://localhost:8080/...","surface":"desktop","checkedAt":"2026-07-05T00:00:00.000Z","captures":["assets/marketing/playdrop/screenshots/landscape/gameplay.png"],"actions":["start game","verify input works","reach loop progression or loss"],"statesObserved":["ready","input works","loop progressed"],"consoleErrors":[]}]} Include at least one non-final entry whose checkedAt is after the last source code change. The uploader appends the final published-route entry automatically.';
+function formatMissingPlaytestEvidenceManifestError(message) {
+    return `agent_task_playtest_manifest_missing: ${message} ${PLAYTEST_EVIDENCE_MANIFEST_HELP}`;
+}
+function formatPlaytestEvidenceManifestError(message) {
+    return `agent_task_playtest_manifest_invalid: ${message} ${PLAYTEST_EVIDENCE_MANIFEST_HELP}`;
+}
+function assertStringArrayField(value, field, options) {
+    if (!Array.isArray(value)) {
+        throw new Error(formatPlaytestEvidenceManifestError(`${field} must be an array.`));
+    }
+    const strings = value.map((entry) => typeof entry === 'string' ? entry.trim() : '');
+    if (strings.some((entry) => entry.length === 0)) {
+        throw new Error(formatPlaytestEvidenceManifestError(`${field} entries must be non-empty strings.`));
+    }
+    if (!options?.allowEmpty && strings.length === 0) {
+        throw new Error(formatPlaytestEvidenceManifestError(`${field} must include at least one entry.`));
+    }
+    return strings;
+}
+function assertPlaytestCapturePaths(task, captures) {
+    for (const capture of captures) {
+        const capturePath = (0, node_path_1.resolve)(task.projectDir, capture);
+        const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(task.projectDir), capturePath).replace(/\\/g, '/');
+        if (relativePath === '' || relativePath === '..' || relativePath.startsWith('../') || relativePath.startsWith('/')) {
+            throw new Error(formatPlaytestEvidenceManifestError('capture paths must stay inside the project.'));
+        }
+        if (!(0, node_fs_1.existsSync)(capturePath) || !(0, node_fs_1.statSync)(capturePath).isFile()) {
+            throw new Error(formatPlaytestEvidenceManifestError(`capture file "${capture}" does not exist.`));
+        }
+    }
+}
+function assertNewGamePlaytestEvidenceManifest(task) {
+    const manifest = readPlaytestEvidenceManifest(task);
+    const entries = Array.isArray(manifest.entries) ? manifest.entries : [];
+    if (entries.length === 0) {
+        throw new Error(formatPlaytestEvidenceManifestError('playtest-evidence.json entries must include a non-final self-playtest before upload.'));
+    }
+    const sourceLastModifiedAt = readRuntimeSourceLastModifiedAt(task.projectDir);
+    const latestSourceMs = sourceLastModifiedAt ? Date.parse(sourceLastModifiedAt) : null;
+    let hasCurrentSelfPlaytest = false;
+    entries.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error(formatPlaytestEvidenceManifestError(`entries[${index}] must be an object.`));
+        }
+        const record = entry;
+        const environment = typeof record.environment === 'string' ? record.environment.trim() : '';
+        const url = typeof record.url === 'string' ? record.url.trim() : '';
+        const surface = typeof record.surface === 'string' ? record.surface.trim() : '';
+        const checkedAt = typeof record.checkedAt === 'string' ? record.checkedAt.trim() : '';
+        if (!environment || !url || !surface || !checkedAt) {
+            throw new Error(formatPlaytestEvidenceManifestError(`entries[${index}] must include environment, url, surface, and checkedAt.`));
+        }
+        const checkedAtMs = Date.parse(checkedAt);
+        if (!Number.isFinite(checkedAtMs)) {
+            throw new Error(formatPlaytestEvidenceManifestError(`entries[${index}].checkedAt must be an ISO date string.`));
+        }
+        const isFinalGateEntry = environment === 'final';
+        const captures = assertStringArrayField(record.captures, `entries[${index}].captures`, { allowEmpty: isFinalGateEntry });
+        assertStringArrayField(record.actions, `entries[${index}].actions`);
+        assertStringArrayField(record.statesObserved, `entries[${index}].statesObserved`, { allowEmpty: isFinalGateEntry });
+        assertStringArrayField(record.consoleErrors, `entries[${index}].consoleErrors`, { allowEmpty: true });
+        assertPlaytestCapturePaths(task, captures);
+        if (!isFinalGateEntry && (latestSourceMs === null || checkedAtMs >= latestSourceMs)) {
+            hasCurrentSelfPlaytest = true;
+        }
     });
+    if (!hasCurrentSelfPlaytest) {
+        throw new Error(formatPlaytestEvidenceManifestError(`playtest-evidence.json must include a non-final self-playtest checkedAt after the last source change${sourceLastModifiedAt ? ` (${sourceLastModifiedAt})` : ''}.`));
+    }
+}
+function writeFinalPublishedRouteEvidence(input) {
+    const manifest = readPlaytestEvidenceManifest(input.task);
+    const entries = Array.isArray(manifest.entries) ? manifest.entries : [];
+    const finalEntry = {
+        environment: 'final',
+        url: input.url,
+        surface: 'DESKTOP',
+        captures: [],
+        actions: ['open owner draft play URL'],
+        statesObserved: input.status === 'PASSED' ? ['ready', 'nonblank-first-frame'] : [],
+        consoleErrors: input.message ? [input.message] : [],
+        checkedAt: input.checkedAt,
+        sourceLastModifiedAt: readRuntimeSourceLastModifiedAt(input.task.projectDir),
+    };
+    const nextManifest = {
+        ...manifest,
+        version: 1,
+        entries: [...entries, finalEntry],
+        finalPublishedRoute: finalEntry,
+    };
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(input.task.projectDir, 'playtest-evidence.json'), `${JSON.stringify(nextManifest, null, 2)}\n`, 'utf8');
+}
+function readRuntimeSourceLastModifiedAt(rootDir) {
+    const root = (0, node_path_1.resolve)(rootDir);
+    let latest = 0;
+    const walk = (dir) => {
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            const absolute = (0, node_path_1.join)(dir, entry.name);
+            const relativePath = absolute.slice(root.length + 1).replace(/\\/g, '/');
+            if (entry.isDirectory()) {
+                if (RUNTIME_SOURCE_EXCLUDED_DIRS.has(entry.name) || RUNTIME_SOURCE_EXCLUDED_DIRS.has(relativePath)) {
+                    continue;
+                }
+                walk(absolute);
+                continue;
+            }
+            if (!entry.isFile() || !RUNTIME_SOURCE_EXTENSIONS.has((0, node_path_1.extname)(entry.name).toLowerCase())) {
+                continue;
+            }
+            latest = Math.max(latest, (0, node_fs_1.statSync)(absolute).mtimeMs);
+        }
+    };
+    walk(root);
+    return latest > 0 ? new Date(latest).toISOString() : null;
 }
 // Task upload path used by "playdrop task upload": same internal pipeline as
 // "playdrop project publish", but always as one PRIVATE draft version for the
@@ -2101,9 +2316,6 @@ async function publishWorkerAppProject(input) {
     }
     if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
         assertNewGameHeroListingArt(task);
-        if (!appTaskHasRequiredNewGameAssets(task)) {
-            throw new Error('agent_task_game_assets_missing: new game tasks must declare at least one real owned asset, PlayDrop asset, or PlayDrop asset pack in catalogue.json.');
-        }
     }
     if (!appTaskSatisfiesPlaydropAssetRequirement(task, input.playdropAssetRequirement)) {
         throw new Error('agent_task_playdrop_asset_dependency_missing: the creator asked for PlayDrop assets, but catalogue.json does not declare a matching uses.assets, uses.packs, or ownedAssets dependency.');
@@ -2114,13 +2326,20 @@ async function publishWorkerAppProject(input) {
             task,
         });
         await assertNewGameOwnedRuntimeImageAssetsAreClean(task);
-        assertNewGameDeclaredAssetsAreUsedAtRuntime(task);
     }
     assertRequestedPlaydropAssetsAreUsedAtRuntime({
         task,
         requirement: input.playdropAssetRequirement,
         creatorRequest: input.creatorRequest,
     });
+    if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
+        await assertNewGameDeclaredAssetsAreUsedAtRuntime({
+            client: input.client,
+            apiBase: input.apiBase,
+            creatorUsername,
+            task,
+        });
+    }
     await assertDeclared3dPlaydropPacksContainRuntimeModels({
         client: input.client,
         task,
@@ -2135,6 +2354,10 @@ async function publishWorkerAppProject(input) {
     if (typeof app.id !== 'number' || !Number.isInteger(app.id) || app.id <= 0) {
         throw new Error(`App "${task.name}" registration did not return an app id.`);
     }
+    if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
+        assertNewGameListingScreenshots(task);
+        assertNewGamePlaytestEvidenceManifest(task);
+    }
     const { upload: uploadResult, warnings } = await (0, apps_1.runAppPipeline)(input.client, task, {
         creatorUsername,
         apiBase: input.apiBase,
@@ -2155,6 +2378,28 @@ async function publishWorkerAppProject(input) {
     if (typeof uploadResult.versionNodeId !== 'string' || uploadResult.versionNodeId.trim().length === 0) {
         throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
     }
+    const finalPlayUrl = (0, appUrls_1.buildPlatformPrivateDraftPlayUrl)(input.webBase ?? null, {
+        creatorUsername,
+        appName: task.name,
+        appType: task.type ?? 'GAME',
+        version: uploadResult.version,
+    });
+    const finalPlayCheck = await (0, launchCheck_1.runPublishedHostedPlayCheck)({
+        targetUrl: finalPlayUrl,
+        surfaceTargets: task.surfaceTargets,
+        token: input.token,
+        currentUser: input.user,
+    });
+    writeFinalPublishedRouteEvidence({
+        task,
+        url: finalPlayUrl,
+        checkedAt: finalPlayCheck.checkedAt,
+        status: finalPlayCheck.status,
+        message: finalPlayCheck.message,
+    });
+    if (finalPlayCheck.status !== 'PASSED') {
+        throw new Error((0, launchCheck_1.formatHostedLaunchCheckFailure)(task.name, finalPlayCheck, 'final'));
+    }
     return {
         appId: app.id,
         appVersionId: uploadResult.versionId,

package/dist/commands/worker.d.ts

@@ -5,7 +5,7 @@ import { type LoggedProcessResult, type LoggedProcessTranscriptChunk } from './w
 export { DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, assertWorkerTokenUsageWithinCap, buildCodexExecArgs, buildClaudeExecArgs, buildClaudePermissionSettings, buildWorkerChildEnv, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractCodexThreadId, extractCodexTokensUsed, readEnvBoolean, readCodexSandboxMode, readCodexRolloutTokenUsageForThread, runLoggedProcess, } from './worker/runtime';
 export type { AgentTokenUsage, LoggedProcessResult, LoggedProcessTranscriptChunk, } from './worker/runtime';
 export declare const WORKER_SESSION_EXPIRED_MESSAGE = "worker session expired: run \"playdrop auth login\" and start the worker again";
-export declare const WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/capture, read-only catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
+export declare const WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
 type WorkerStartOptions = {
     env?: string;
     once?: boolean;
@@ -77,6 +77,7 @@ type TaskCatalogueReportOptions = {
 type TaskCompleteOptions = {
     env?: string;
     nextSteps?: string;
+    summary?: string;
 };
 type TaskClaimSlugOptions = {
     appName?: string;
@@ -98,6 +99,10 @@ type TaskSubmitReviewOptions = {
     evidenceDir?: string;
     nextSteps?: string;
 };
+type TaskSubmitEvalOptions = {
+    env?: string;
+    resultFile?: string;
+};
 export type WorkerHealthAlertInput = {
     state: 'started' | 'stopped' | 'crashed';
     env: string;
@@ -157,6 +162,10 @@ export declare function stagePlaydropPluginReferences(input: {
     pluginRoot: string;
     kind: AgentTaskKind;
 }): Promise<string[]>;
+export declare function stageAssignmentPluginBundle(input: {
+    workspaceDir: string;
+    pluginBundle: NonNullable<WorkerAgentTaskAssignmentResponse['pluginBundle']>;
+}): Promise<string>;
 export declare function discoverWorkerProjectRoot(workspaceDir: string): string;
 export declare function readWorkerTaskState(): WorkerTaskState | null;
 export declare function buildWorkerHealthAlertText(input: WorkerHealthAlertInput): string;
@@ -181,6 +190,7 @@ export declare function buildWorkerCapabilities(input: string | {
     } | null;
     maxParallelTasks?: number | null;
     runningTaskCount?: number | null;
+    providerAccountLabel?: string | null;
 }): AgentWorkerCapabilities;
 export declare function buildWorkerClaimBody(input: {
     workerKey: string;
@@ -254,4 +264,5 @@ export declare function readReviewEvidenceFiles(evidenceDir: string | undefined)
     contentBase64: string;
 }>;
 export declare function submitReviewTask(options: TaskSubmitReviewOptions): Promise<void>;
+export declare function submitEvalTask(options: TaskSubmitEvalOptions): Promise<void>;
 export declare function failTask(options: TaskFailOptions): Promise<void>;