@playdrop/playdrop-cli 0.12.41 → 0.13.0

package/dist/commands/worker.js

@@ -3,7 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": 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.extractCodexRolloutTokenUsage = exports.extractAgentTokenUsage = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CODEX_TIMEOUT_MS = exports.buildWorkerChildEnv = exports.buildPlaywrightMcpCommand = exports.buildCodexExecArgs = exports.buildClaudePermissionSettings = exports.buildClaudeExecArgs = exports.assertWorkerTokenUsageWithinCap = void 0;
+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.buildCreatorRecoveryPrompt = buildCreatorRecoveryPrompt;
+exports.buildGameEvalRetryPrompt = buildGameEvalRetryPrompt;
 exports.allocateWorkerDevPort = allocateWorkerDevPort;
 exports.isWorkerContextCommandAllowed = isWorkerContextCommandAllowed;
 exports.resolveWorkerExecutionTargetFromRole = resolveWorkerExecutionTargetFromRole;
@@ -12,6 +15,7 @@ exports.nextClaimBackoffMs = nextClaimBackoffMs;
 exports.claimBackoffDelayMs = claimBackoffDelayMs;
 exports.resolveWorkerHomeDir = resolveWorkerHomeDir;
 exports.pruneWorkerTaskWorkspaces = pruneWorkerTaskWorkspaces;
+exports.prepareClaimedTaskWorkspace = prepareClaimedTaskWorkspace;
 exports.resolveWorkerInstrumentSurface = resolveWorkerInstrumentSurface;
 exports.hasAgentTaskUploadedArtifact = hasAgentTaskUploadedArtifact;
 exports.appendWorkerTranscriptChunks = appendWorkerTranscriptChunks;
@@ -19,6 +23,7 @@ exports.readTaskNextStepsFile = readTaskNextStepsFile;
 exports.assertTaskUploadResultMatchesContext = assertTaskUploadResultMatchesContext;
 exports.stageAssignmentWorkspaceV2 = stageAssignmentWorkspaceV2;
 exports.assertAssignmentPluginBundleExtractionBounds = assertAssignmentPluginBundleExtractionBounds;
+exports.stageDevPluginWorkingTree = stageDevPluginWorkingTree;
 exports.stageAssignmentPluginBundle = stageAssignmentPluginBundle;
 exports.resolveDevPluginWorkingTree = resolveDevPluginWorkingTree;
 exports.discoverWorkerProjectRoot = discoverWorkerProjectRoot;
@@ -43,6 +48,7 @@ exports.prepareCodexRunHomes = prepareCodexRunHomes;
 exports.prepareClaudeRunConfig = prepareClaudeRunConfig;
 exports.removeAgentRunCredentials = removeAgentRunCredentials;
 exports.removeStaleAgentRunCredentials = removeStaleAgentRunCredentials;
+exports.mergeCreatorRecoveryResults = mergeCreatorRecoveryResults;
 exports.buildAgentFailureCode = buildAgentFailureCode;
 exports.describeAgentFailureForEvent = describeAgentFailureForEvent;
 exports.createLocalPlaydropShim = createLocalPlaydropShim;
@@ -71,6 +77,7 @@ exports.showWorkerStatus = showWorkerStatus;
 exports.setupWorker = setupWorker;
 exports.instrumentTaskChromeTitleMatchers = instrumentTaskChromeTitleMatchers;
 exports.enforceInstrumentBrowserHygiene = enforceInstrumentBrowserHygiene;
+exports.assignmentRequiresRegisteredBundle = assignmentRequiresRegisteredBundle;
 exports.startWorker = startWorker;
 exports.reportTask = reportTask;
 exports.showTaskContext = showTaskContext;
@@ -110,13 +117,17 @@ var runtime_2 = require("./worker/runtime");
 Object.defineProperty(exports, "assertWorkerTokenUsageWithinCap", { enumerable: true, get: function () { return runtime_2.assertWorkerTokenUsageWithinCap; } });
 Object.defineProperty(exports, "buildClaudeExecArgs", { enumerable: true, get: function () { return runtime_2.buildClaudeExecArgs; } });
 Object.defineProperty(exports, "buildClaudePermissionSettings", { enumerable: true, get: function () { return runtime_2.buildClaudePermissionSettings; } });
+Object.defineProperty(exports, "buildCleanRoomChildEnv", { enumerable: true, get: function () { return runtime_2.buildCleanRoomChildEnv; } });
 Object.defineProperty(exports, "buildCodexExecArgs", { enumerable: true, get: function () { return runtime_2.buildCodexExecArgs; } });
 Object.defineProperty(exports, "buildPlaywrightMcpCommand", { enumerable: true, get: function () { return runtime_2.buildPlaywrightMcpCommand; } });
 Object.defineProperty(exports, "buildWorkerChildEnv", { enumerable: true, get: function () { return runtime_2.buildWorkerChildEnv; } });
 Object.defineProperty(exports, "DEFAULT_CODEX_TIMEOUT_MS", { enumerable: true, get: function () { return runtime_2.DEFAULT_CODEX_TIMEOUT_MS; } });
+Object.defineProperty(exports, "DEFAULT_CREATOR_AGENT_TIMEOUT_MS", { enumerable: true, get: function () { return runtime_2.DEFAULT_CREATOR_AGENT_TIMEOUT_MS; } });
+Object.defineProperty(exports, "DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS", { enumerable: true, get: function () { return runtime_2.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS; } });
 Object.defineProperty(exports, "DEFAULT_WORKER_TOKEN_CAP", { enumerable: true, get: function () { return runtime_2.DEFAULT_WORKER_TOKEN_CAP; } });
 Object.defineProperty(exports, "extractAgentTokenUsage", { enumerable: true, get: function () { return runtime_2.extractAgentTokenUsage; } });
 Object.defineProperty(exports, "extractCodexRolloutTokenUsage", { enumerable: true, get: function () { return runtime_2.extractCodexRolloutTokenUsage; } });
+Object.defineProperty(exports, "extractClaudeSessionId", { enumerable: true, get: function () { return runtime_2.extractClaudeSessionId; } });
 Object.defineProperty(exports, "extractCodexThreadId", { enumerable: true, get: function () { return runtime_2.extractCodexThreadId; } });
 Object.defineProperty(exports, "extractCodexTokensUsed", { enumerable: true, get: function () { return runtime_2.extractCodexTokensUsed; } });
 Object.defineProperty(exports, "readCodexRolloutTokenUsageForThread", { enumerable: true, get: function () { return runtime_2.readCodexRolloutTokenUsageForThread; } });
@@ -137,7 +148,9 @@ 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 = 2;
-const WORKER_SUPPORTED_KINDS = ['NEW_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'];
+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);
 const AGENT_BUNDLE_MANIFEST_PATH = 'agent-bundle.json';
 const ASSIGNMENT_PLUGIN_BUNDLE_MAX_FILES = 1000;
@@ -148,6 +161,36 @@ const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
 const ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES = 22;
 const ZIP_MAX_COMMENT_BYTES = 0xffff;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function usesCreatorRecovery(kind) {
+    return GAME_CREATION_TASK_KINDS.has(kind);
+}
+function buildCreatorRecoveryPrompt(input) {
+    const prompt = input.prompt.trim();
+    if (!prompt) {
+        throw new Error('agent_task_assignment_prompt_missing');
+    }
+    if (!GAME_CREATION_TASK_KINDS.has(input.kind)) {
+        throw new Error(`agent_task_creation_recovery_unsupported:${input.kind}`);
+    }
+    const finishInstruction = AGENT_MANAGED_UPLOAD_TASK_KINDS.has(input.kind)
+        ? 'Prioritize `playdrop task upload` and then `playdrop task done`.'
+        : 'Finish a valid standalone `index.html` at the project root, then stop so the worker can publish it.';
+    return [
+        'This task was paused because it was taking too long. Continue from the existing workspace and do not restart or redesign the game.',
+        'You have 10 minutes to finish the strongest solid version already present. Make only the smallest fixes required for validation and publishing.',
+        `${finishInstruction} Do not add features or polish. If completion cannot succeed, report the exact blocker and stop.`,
+        `Original request: ${prompt}`,
+    ].join('\n\n');
+}
+function buildGameEvalRetryPrompt(prompt) {
+    return [
+        prompt,
+        '',
+        'This is a retry in the existing evaluation workspace.',
+        'Reuse the existing result.json and evidence. Do not replay completed game checks unless required evidence is missing or invalid.',
+        'First correct any deterministic submission-contract error, then submit the existing result and evidence and finish.',
+    ].join('\n');
+}
 exports.WORKER_SESSION_EXPIRED_MESSAGE = 'worker session expired: run "playdrop auth login" and start the worker again';
 const WORKER_CONTEXT_ALLOWED_COMMANDS = [
     ['task', 'context'],
@@ -505,6 +548,29 @@ async function pruneWorkerTaskWorkspaces(incomingWorkspaceDir, retention = expor
     }
     return removed;
 }
+async function prepareClaimedTaskWorkspace(input) {
+    await pruneWorkerTaskWorkspaces(input.workspaceDir);
+    const resumed = input.attempt > 1 && (0, node_fs_1.existsSync)(input.workspaceDir);
+    if (!resumed) {
+        await (0, promises_1.rm)(input.workspaceDir, { recursive: true, force: true });
+        await (0, promises_1.mkdir)(input.workspaceDir, { recursive: true });
+        return { resumed: false };
+    }
+    await removeAgentRunCredentials(input.workspaceDir);
+    const retainedProjectBindings = [
+        node_path_1.default.join(input.workspaceDir, '.playdrop.json'),
+        ...(0, node_fs_1.readdirSync)(input.workspaceDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && entry.name !== '.playdrop')
+            .map((entry) => node_path_1.default.join(input.workspaceDir, entry.name, '.playdrop.json')),
+    ];
+    await Promise.all([
+        (0, promises_1.rm)(node_path_1.default.join(input.workspaceDir, '.playdrop', 'task-events'), { recursive: true, force: true }),
+        (0, promises_1.rm)(node_path_1.default.join(input.workspaceDir, '.playdrop', 'task-upload.lock'), { force: true }),
+        (0, promises_1.rm)(node_path_1.default.join(input.workspaceDir, '.playdrop', 'task-upload-result.json'), { force: true }),
+        ...retainedProjectBindings.map((file) => (0, promises_1.rm)(file, { force: true })),
+    ]);
+    return { resumed: true };
+}
 function buildWorkerTaskContext(input) {
     const playdrop = input.metadata.playdrop;
     if (!playdrop || typeof playdrop !== 'object' || Array.isArray(playdrop)) {
@@ -512,7 +578,7 @@ function buildWorkerTaskContext(input) {
     }
     const metadata = playdrop;
     const kind = metadata.kind;
-    if (kind !== 'NEW_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') {
         throw new Error('agent_task_context_kind_missing');
     }
     const creatorUsername = typeof metadata.creatorUsername === 'string'
@@ -583,6 +649,23 @@ function resolveWorkerInstrumentSurface(taskContext) {
         return null;
     }
     const metadata = playdrop;
+    if (taskContext.kind === 'STATIC_GAME') {
+        const surfaceContext = metadata.surfaceContext;
+        if (!surfaceContext || typeof surfaceContext !== 'object' || Array.isArray(surfaceContext)) {
+            return null;
+        }
+        const context = surfaceContext;
+        if (context.deviceClass === 'DESKTOP') {
+            return 'DESKTOP';
+        }
+        if (context.orientation === 'PORTRAIT') {
+            return 'MOBILE_PORTRAIT';
+        }
+        if (context.orientation === 'LANDSCAPE') {
+            return 'MOBILE_LANDSCAPE';
+        }
+        return null;
+    }
     if (taskContext.kind === 'GAME_REVIEW') {
         const reviewTarget = metadata.reviewTarget;
         if (!reviewTarget || typeof reviewTarget !== 'object' || Array.isArray(reviewTarget)) {
@@ -1073,17 +1156,19 @@ function readAgentBundleManifest(extractedRoot) {
     }
     const manifest = parsed;
     if (manifest.version !== 1
-        || !manifest.plugin
-        || typeof manifest.plugin.root !== 'string'
+        || !Object.prototype.hasOwnProperty.call(manifest, 'plugin')
+        || (manifest.plugin !== null && typeof manifest.plugin?.root !== 'string')
         || !manifest.workspace
         || !Array.isArray(manifest.workspace.files)) {
         throw new Error('agent_bundle_manifest_invalid');
     }
-    const pluginRoot = normalizeAgentBundlePath(extractedRoot, manifest.plugin.root, 'agent_bundle_plugin_root_invalid');
-    if (!isFile(node_path_1.default.join(pluginRoot, '.codex-plugin', 'plugin.json'))) {
+    const pluginRoot = manifest.plugin === null
+        ? null
+        : normalizeAgentBundlePath(extractedRoot, manifest.plugin?.root, 'agent_bundle_plugin_root_invalid');
+    if (pluginRoot && !isFile(node_path_1.default.join(pluginRoot, '.codex-plugin', 'plugin.json'))) {
         throw new Error('agent_bundle_codex_plugin_manifest_missing');
     }
-    if (!isFile(node_path_1.default.join(pluginRoot, '.claude-plugin', 'plugin.json'))) {
+    if (pluginRoot && !isFile(node_path_1.default.join(pluginRoot, '.claude-plugin', 'plugin.json'))) {
         throw new Error('agent_bundle_claude_plugin_manifest_missing');
     }
     const destinations = new Set();
@@ -1146,6 +1231,19 @@ async function stageAgentBundleWorkspaceFiles(extractedRoot, workspaceDir, taskK
     }
     return resolved.pluginRoot;
 }
+async function stageDevPluginWorkingTree(input) {
+    const sourceRoot = node_path_1.default.resolve(input.workingTree);
+    readAgentBundleManifest(sourceRoot);
+    const snapshotRoot = node_path_1.default.join(input.workspaceDir, '.playdrop', 'dev-task-plugin');
+    await (0, promises_1.rm)(snapshotRoot, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(snapshotRoot), { recursive: true });
+    await (0, promises_1.cp)(sourceRoot, snapshotRoot, { recursive: true });
+    const pluginRoot = await stageAgentBundleWorkspaceFiles(snapshotRoot, input.workspaceDir, input.taskKind);
+    if (!pluginRoot) {
+        throw new Error('worker_dev_plugin_working_tree_requires_plugin');
+    }
+    return pluginRoot;
+}
 async function stageAssignmentPluginBundle(input) {
     const sha256 = typeof input.pluginBundle.sha256 === 'string' ? input.pluginBundle.sha256.trim() : '';
     const fileName = typeof input.pluginBundle.fileName === 'string' ? input.pluginBundle.fileName.trim() : '';
@@ -1168,7 +1266,7 @@ async function stageAssignmentPluginBundle(input) {
         throw new Error('agent_task_plugin_bundle_sha_mismatch');
     }
     assertAssignmentPluginBundleExtractionBounds(buffer);
-    const pluginRoot = node_path_1.default.join(input.workspaceDir, '.playdrop', 'task-plugin');
+    const pluginRoot = node_path_1.default.join(input.extractionDir ?? input.workspaceDir, '.playdrop', 'task-plugin');
     await (0, promises_1.rm)(pluginRoot, { recursive: true, force: true });
     await (0, promises_1.mkdir)(pluginRoot, { recursive: true });
     const entries = (0, fflate_1.unzipSync)(new Uint8Array(buffer));
@@ -1215,7 +1313,9 @@ function resolveDevPluginWorkingTree(input) {
         throw new Error(`worker_dev_plugin_working_tree_requires_dev_environment:${input.env}`);
     }
     const resolved = node_path_1.default.resolve(workingTree);
-    readAgentBundleManifest(resolved);
+    if (!readAgentBundleManifest(resolved).pluginRoot) {
+        throw new Error('worker_dev_plugin_working_tree_requires_plugin');
+    }
     return resolved;
 }
 // A PlayDrop project root is the topmost directory holding a catalogue.json,
@@ -1900,11 +2000,15 @@ async function prepareCodexRunHomes(input) {
     const runRoot = node_path_1.default.join(input.workspaceDir, '.playdrop', 'codex-run');
     const homeDir = node_path_1.default.join(runRoot, 'home');
     const codexHomeDir = node_path_1.default.join(runRoot, 'codex-home');
-    await (0, promises_1.rm)(runRoot, { recursive: true, force: true });
+    if (!input.preserveExisting) {
+        await (0, promises_1.rm)(runRoot, { recursive: true, force: true });
+    }
     await (0, promises_1.mkdir)(runRoot, { recursive: true, mode: 0o700 });
     await (0, promises_1.chmod)(runRoot, 0o700);
-    await (0, promises_1.mkdir)(homeDir, { mode: 0o700 });
-    await (0, promises_1.mkdir)(codexHomeDir, { mode: 0o700 });
+    await (0, promises_1.mkdir)(homeDir, { recursive: true, mode: 0o700 });
+    await (0, promises_1.chmod)(homeDir, 0o700);
+    await (0, promises_1.mkdir)(codexHomeDir, { recursive: true, mode: 0o700 });
+    await (0, promises_1.chmod)(codexHomeDir, 0o700);
     const sourceCodexHome = node_path_1.default.resolve(input.sourceCodexHome?.trim()
         || node_process_1.default.env.CODEX_HOME?.trim()
         || node_path_1.default.join(node_os_1.default.homedir(), '.codex'));
@@ -1915,12 +2019,14 @@ async function prepareCodexRunHomes(input) {
     const stagedAuthPath = node_path_1.default.join(codexHomeDir, 'auth.json');
     await (0, promises_1.copyFile)(sourceAuthPath, stagedAuthPath);
     await (0, promises_1.chmod)(stagedAuthPath, 0o600);
-    await stageWorkerPlaydropSession({
-        homeDir,
-        workerUsername: input.workerUsername,
-        envName: input.envName,
-        playdropConfig: input.playdropConfig,
-    });
+    if (input.stagePlaydropSession !== false) {
+        await stageWorkerPlaydropSession({
+            homeDir,
+            workerUsername: input.workerUsername,
+            envName: input.envName,
+            playdropConfig: input.playdropConfig,
+        });
+    }
     return { homeDir, codexHomeDir };
 }
 async function stageWorkerPlaydropSession(input) {
@@ -1999,11 +2105,13 @@ async function removeStaleAgentRunCredentials(workerHomeDir = resolveWorkerHomeD
 }
 async function runCodex(input) {
     const { homeDir, codexHomeDir } = await prepareCodexRunHomes({
-        workspaceDir: input.workspaceDir,
+        workspaceDir: input.stateDir ?? input.workspaceDir,
         workerUsername: input.workerUsername,
         envName: input.envName,
+        stagePlaydropSession: !input.cleanRoom,
+        preserveExisting: Boolean(input.resumeSessionId),
     });
-    if (input.taskPluginRoot) {
+    if (input.taskPluginRoot && !input.resumeSessionId) {
         const pluginEnv = {
             ...node_process_1.default.env,
             HOME: homeDir,
@@ -2018,7 +2126,7 @@ async function runCodex(input) {
             env: pluginEnv,
         });
     }
-    if (input.enablePlaywrightMcp) {
+    if (input.enablePlaywrightMcp && !input.resumeSessionId) {
         const server = (0, runtime_1.buildPlaywrightMcpCommand)(input.instrumentSurface);
         await execFileAsync('codex', ['mcp', 'add', 'playwright', '--', server.command, ...server.args], {
             cwd: input.workspaceDir,
@@ -2040,12 +2148,17 @@ async function runCodex(input) {
             workspaceDir: input.workspaceDir,
             model: input.codexModel.model,
             reasoningEffort: input.codexModel.reasoningEffort,
-            networkAccess: (0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_AGENT_NETWORK_ACCESS', false),
+            networkAccess: input.cleanRoom || (0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_AGENT_NETWORK_ACCESS', false),
             sandboxMode: (0, runtime_1.readCodexSandboxMode)(),
             imagePaths: input.imagePaths,
+            resumeSessionId: input.resumeSessionId,
         }),
         cwd: input.workspaceDir,
-        env: (0, runtime_1.buildWorkerChildEnv)({
+        env: input.cleanRoom ? (0, runtime_1.buildCleanRoomChildEnv)({
+            binDir: input.binDir,
+            homeDir,
+            codexHomeDir,
+        }) : (0, runtime_1.buildWorkerChildEnv)({
             binDir: input.binDir,
             taskId: input.taskId,
             taskToken: input.taskToken,
@@ -2058,7 +2171,7 @@ async function runCodex(input) {
             playwrightBrowsersPath: resolveWorkerPlaywrightBrowsersPath(),
         }),
         stdin: input.prompt,
-        timeoutMs: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CODEX_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
+        timeoutMs: input.timeoutMs ?? (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CODEX_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
         maxOutputChars: runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS,
         onTranscriptChunks: async (chunks) => {
             if (!observedCodexThreadId) {
@@ -2080,16 +2193,17 @@ async function runCodex(input) {
         if (result.tokenUsage.usageParseError) {
             console.warn('Codex thread id was not observed; rollout token usage could not be read.');
         }
-        return result;
+        return { ...result, providerSessionId: null };
     }
     const rolloutUsage = await (0, runtime_1.readCodexRolloutTokenUsageForThread)(observedCodexThreadId, {
         sessionsRoot: node_path_1.default.join(codexHomeDir, 'sessions'),
+        deleteAfterRead: false,
     });
     if (rolloutUsage.usageParseError || rolloutUsage.totalTokens === null) {
         if (result.tokenUsage.usageParseError) {
             console.warn(`Codex rollout token usage could not be read for thread ${observedCodexThreadId}: ${rolloutUsage.usageParseError ?? 'unknown_error'}.`);
         }
-        return result;
+        return { ...result, providerSessionId: observedCodexThreadId };
     }
     if (!result.tokenUsage.usageParseError
         && result.tokenUsage.totalTokens !== null
@@ -2098,20 +2212,25 @@ async function runCodex(input) {
     }
     return {
         ...result,
+        providerSessionId: observedCodexThreadId,
         tokenUsage: rolloutUsage,
         tokensUsed: rolloutUsage.totalTokens,
     };
 }
 async function runClaude(input) {
-    const { playdropConfigPath } = await prepareClaudeRunConfig({
-        workspaceDir: input.workspaceDir,
-        workerUsername: input.workerUsername,
-        envName: input.envName,
-    });
+    const playdropConfigPath = input.cleanRoom
+        ? null
+        : (await prepareClaudeRunConfig({
+            workspaceDir: input.stateDir ?? input.workspaceDir,
+            workerUsername: input.workerUsername,
+            envName: input.envName,
+        })).playdropConfigPath;
     const denyReadRoots = resolveClaudeDenyReadRoots(input.workspaceDir);
     const screenshotCollector = input.enableChrome || input.enablePlaywrightMcp
         ? (0, instrument_evidence_1.createWorkerInstrumentScreenshotCollector)(input.workspaceDir)
         : null;
+    let observedClaudeSessionId = input.resumeSessionId?.trim() || null;
+    let claudeSessionProbe = '';
     let playwrightMcpConfigPath = null;
     if (input.enablePlaywrightMcp) {
         playwrightMcpConfigPath = node_path_1.default.join(input.workspaceDir, '.playdrop', 'claude-run', 'playwright-mcp.json');
@@ -2125,12 +2244,16 @@ async function runClaude(input) {
             workspaceDir: input.workspaceDir,
             denyReadRoots,
             pluginDir: input.taskPluginRoot,
+            playdropCliEnabled: !input.cleanRoom,
             chrome: input.enableChrome,
             playwrightMcp: input.enablePlaywrightMcp,
             playwrightMcpConfigPath,
+            resumeSessionId: input.resumeSessionId,
         }),
         cwd: input.workspaceDir,
-        env: (0, runtime_1.buildWorkerChildEnv)({
+        env: input.cleanRoom ? (0, runtime_1.buildCleanRoomChildEnv)({
+            binDir: input.binDir,
+        }) : (0, runtime_1.buildWorkerChildEnv)({
             binDir: input.binDir,
             taskId: input.taskId,
             taskToken: input.taskToken,
@@ -2138,7 +2261,7 @@ async function runClaude(input) {
             envName: input.envName,
             eventDir: input.eventDir,
             devPort: input.devPort,
-            playdropConfigPath,
+            playdropConfigPath: playdropConfigPath,
             playwrightBrowsersPath: resolveWorkerPlaywrightBrowsersPath(),
         }),
         stdin: `${JSON.stringify({
@@ -2158,9 +2281,15 @@ async function runClaude(input) {
                 ],
             },
         })}\n`,
-        timeoutMs: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CLAUDE_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
+        timeoutMs: input.timeoutMs ?? (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CLAUDE_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
         maxOutputChars: runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS,
-        onTranscriptChunks: input.onTranscriptChunks,
+        onTranscriptChunks: async (chunks) => {
+            if (!observedClaudeSessionId) {
+                claudeSessionProbe = (claudeSessionProbe + chunks.map((chunk) => chunk.content).join('')).slice(-64000);
+                observedClaudeSessionId = (0, runtime_1.extractClaudeSessionId)(claudeSessionProbe);
+            }
+            await input.onTranscriptChunks(chunks);
+        },
         ...(screenshotCollector
             ? { onStdoutText: (text) => screenshotCollector.push(text) > 0 }
             : {}),
@@ -2168,7 +2297,9 @@ async function runClaude(input) {
         onChild: input.onChild,
     });
     screenshotCollector?.finish();
-    return result;
+    observedClaudeSessionId = observedClaudeSessionId
+        ?? (0, runtime_1.extractClaudeSessionId)(`${result.stdout}\n${result.stderr}\n${result.outputTail}`);
+    return { ...result, providerSessionId: observedClaudeSessionId };
 }
 function isPathInside(parent, child) {
     const relative = node_path_1.default.relative(parent, child);
@@ -2199,6 +2330,35 @@ function resolveClaudeDenyReadRoots(workspaceDir) {
 }
 // Raw stdout/stderr tails stay out of task results on purpose: transcripts are
 // streamed separately and results can surface to creators (spec section 11).
+function mergeCreatorRecoveryResults(runtime, initial, recovery) {
+    const sumNullable = (left, right) => (left === null && right === null ? null : (left ?? 0) + (right ?? 0));
+    const tokenUsage = runtime === 'CODEX' && recovery.tokenUsage.totalTokens !== null
+        ? recovery.tokenUsage
+        : {
+            inputTokens: sumNullable(initial.tokenUsage.inputTokens, recovery.tokenUsage.inputTokens),
+            outputTokens: sumNullable(initial.tokenUsage.outputTokens, recovery.tokenUsage.outputTokens),
+            cacheCreationInputTokens: sumNullable(initial.tokenUsage.cacheCreationInputTokens, recovery.tokenUsage.cacheCreationInputTokens),
+            cacheReadInputTokens: sumNullable(initial.tokenUsage.cacheReadInputTokens, recovery.tokenUsage.cacheReadInputTokens),
+            totalTokens: sumNullable(initial.tokenUsage.totalTokens, recovery.tokenUsage.totalTokens),
+            rawProviderUsage: {
+                initial: initial.tokenUsage.rawProviderUsage,
+                recovery: recovery.tokenUsage.rawProviderUsage,
+            },
+            usageParseError: initial.tokenUsage.totalTokens === null || recovery.tokenUsage.totalTokens === null
+                ? 'creator_recovery_usage_incomplete'
+                : null,
+        };
+    const recoveryMarker = recovery.timedOut ? '\nagent_task_creation_recovery_timeout' : '';
+    return {
+        ...recovery,
+        stdout: `${initial.stdout}\n${recovery.stdout}`.slice(-runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS),
+        stderr: `${initial.stderr}\n${recovery.stderr}${recoveryMarker}`.slice(-runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS),
+        outputTail: `${initial.outputTail}\n${recovery.outputTail}${recoveryMarker}`.slice(-runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS),
+        tokenUsage,
+        tokensUsed: tokenUsage.totalTokens,
+        providerSessionId: recovery.providerSessionId ?? initial.providerSessionId ?? null,
+    };
+}
 function buildAgentRunResult(result) {
     return {
         exitCode: result.exitCode,
@@ -2326,6 +2486,12 @@ function extractProviderStatusCode(text) {
 function buildAgentFailureCode(agent, result, request) {
     const provider = providerNameForAgent(agent);
     const combinedOutput = `${result.outputTail}\n${result.stderr}\n${result.stdout}`;
+    if (combinedOutput.includes('agent_task_resume_session_missing')) {
+        return `agent_task_resume_session_missing:${provider}`;
+    }
+    if (combinedOutput.includes('agent_task_creation_recovery_timeout')) {
+        return `agent_task_creation_recovery_timeout:${provider}`;
+    }
     if (request
         && (/\b(?:unknown|invalid|unsupported)\s+(?:model|effort)\b/i.test(combinedOutput)
             || /\b(?:model|effort)\b.{0,80}\b(?:not found|not available|does not exist|is unavailable|is not supported)\b/i.test(combinedOutput))) {
@@ -2363,6 +2529,12 @@ function describeAgentFailureForEvent(errorCode) {
     if (code === 'agent_provider_timeout') {
         return `${providerLabel} timed out before completing the task. Retry this task when the provider is healthy.`;
     }
+    if (code === 'agent_task_resume_session_missing') {
+        return `${providerLabel} timed out, but the worker could not recover the same conversation. The task was stopped without starting over.`;
+    }
+    if (code === 'agent_task_creation_recovery_timeout') {
+        return `${providerLabel} did not finish during the final creation recovery window, so the task was stopped permanently.`;
+    }
     if (code === 'worker_shutdown') {
         return 'The worker stopped while running this task. Start the worker again, then retry the task.';
     }
@@ -2422,6 +2594,24 @@ async function createLocalPlaydropShim(input) {
     }
     return binDir;
 }
+async function createStaticGameCleanToolPath(workspaceDir, runtime) {
+    const binDir = node_path_1.default.join(workspaceDir, '.clean-tools');
+    await (0, promises_1.rm)(binDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(binDir, { recursive: true });
+    const commands = runtime === 'CODEX'
+        ? ['codex', 'node', 'npm', 'npx']
+        : ['claude', 'node', 'npm', 'npx'];
+    for (const command of commands) {
+        const target = command === 'node'
+            ? node_process_1.default.execPath
+            : (await execFileAsync('/usr/bin/which', [command])).stdout.trim();
+        if (!target || !node_path_1.default.isAbsolute(target)) {
+            throw new Error(`static_game_clean_tool_missing:${command}`);
+        }
+        (0, node_fs_1.symlinkSync)(target, node_path_1.default.join(binDir, command));
+    }
+    return binDir;
+}
 function probeCodexInstallation() {
     const probe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)('codex'));
     if (probe.exitCode !== 0 || !probe.output.trim()) {
@@ -3799,7 +3989,7 @@ on run matchers
   return "remaining=" & remainingCount & ";blank=" & blankWindowCount
 end run
 `;
-async function enforceInstrumentBrowserHygiene(assignment, options = {}) {
+async function enforceInstrumentBrowserHygieneUnlocked(assignment, options = {}) {
     if (assignment.agent.browser === 'NONE') {
         return { remainingTaskTabs: 0, blankWindows: 0 };
     }
@@ -3814,13 +4004,22 @@ async function enforceInstrumentBrowserHygiene(assignment, options = {}) {
         const result = await execFileAsync(command, args, { timeout: 15000, maxBuffer: 1024 * 1024 });
         return { stdout: result.stdout, stderr: result.stderr };
     });
-    let result;
-    try {
-        result = await runner('osascript', ['-e', INSTRUMENT_BROWSER_HYGIENE_APPLESCRIPT, ...matchers]);
-    }
-    catch (error) {
-        throw new Error(`worker_browser_hygiene_automation_failed:${error instanceof Error ? error.message : String(error)}`);
+    let result = null;
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        try {
+            result = await runner('osascript', ['-e', INSTRUMENT_BROWSER_HYGIENE_APPLESCRIPT, ...matchers]);
+            break;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes('Connection is invalid. (-609)') || attempt === 3) {
+                throw new Error(`worker_browser_hygiene_automation_failed:${message}`);
+            }
+            await sleep(250);
+        }
     }
+    if (!result)
+        throw new Error('worker_browser_hygiene_automation_failed:no_result');
     const match = /remaining=(\d+);blank=(\d+)/.exec(result.stdout.trim());
     if (!match) {
         throw new Error(`worker_browser_hygiene_invalid_result:${result.stdout.trim() || result.stderr.trim() || 'empty'}`);
@@ -3832,12 +4031,25 @@ async function enforceInstrumentBrowserHygiene(assignment, options = {}) {
     }
     return { remainingTaskTabs, blankWindows };
 }
+let instrumentBrowserHygieneTail = Promise.resolve();
+async function enforceInstrumentBrowserHygiene(assignment, options = {}) {
+    const result = instrumentBrowserHygieneTail.then(() => enforceInstrumentBrowserHygieneUnlocked(assignment, options));
+    instrumentBrowserHygieneTail = result.then(() => undefined, () => undefined);
+    return result;
+}
+function assignmentRequiresRegisteredBundle(assignment) {
+    const playdropMetadata = assignment.task.metadata.playdrop;
+    return Boolean(playdropMetadata
+        && typeof playdropMetadata === 'object'
+        && !Array.isArray(playdropMetadata)
+        && playdropMetadata.bundleSource === 'REGISTERED');
+}
 function throwWorkerRuntimeError(error) {
     throw error;
 }
 async function startWorker(options = {}) {
     loadWorkerEnvFile(options.env);
-    await (0, commandContext_1.withEnvironment)('worker start', 'Starting the PlayDrop worker', async ({ client, env }) => {
+    await (0, commandContext_1.withEnvironment)('worker start', 'Starting the PlayDrop worker', async ({ client, env, envConfig, token }) => {
         const devPluginWorkingTree = resolveDevPluginWorkingTree({
             workingTree: options.devPluginWorkingTree,
             env,
@@ -4033,6 +4245,7 @@ async function startWorker(options = {}) {
                 let heartbeatObservedFinalizedTask = false;
                 let retainWorkspace = false;
                 let workspaceDir = null;
+                let agentWorkspaceDir = null;
                 let availableSkillPaths = [];
                 const observedSkillPaths = new Set();
                 const assignment = claimedAssignment;
@@ -4062,6 +4275,38 @@ async function startWorker(options = {}) {
                     });
                     telemetryReported = true;
                 };
+                const failUploadedArtifactWithoutTaskDone = async () => {
+                    const failureCode = 'agent_exited_after_upload_without_task_done';
+                    retainWorkspace = true;
+                    await client.workerCreateAgentTaskEvent(task.id, {
+                        workerKey,
+                        leaseToken,
+                        kind: 'progress',
+                        phase: 'failed',
+                        message: 'The agent uploaded an artifact but exited without marking the task done.',
+                        pct: null,
+                        payload: { error: failureCode },
+                    });
+                    await failTaskWithRetry(client, task.id, {
+                        workerKey,
+                        leaseToken,
+                        error: failureCode,
+                        terminalReason: {
+                            kind: 'failure',
+                            category: 'agent_failure',
+                            code: failureCode,
+                            message: 'The agent uploaded an artifact but did not complete the task protocol.',
+                            retryable: false,
+                            rawError: failureCode,
+                            source: 'agent',
+                        },
+                        result: {
+                            stage: 'completion',
+                            uploadedArtifactPreserved: true,
+                        },
+                    });
+                    await reportTelemetry('FAILED');
+                };
                 try {
                     const codexModel = assignment.agent.runtime === 'CODEX'
                         ? resolveCodexModel(assignment.agent.model, assignment.agent.reasoningEffort)
@@ -4071,24 +4316,35 @@ async function startWorker(options = {}) {
                         : null;
                     resolvedRuntimeModel = codexModel?.model ?? claudeModel?.model ?? assignment.agent.model;
                     reasoningEffort = codexModel?.reasoningEffort ?? claudeModel?.effort ?? null;
+                    const cleanRoom = task.kind === 'STATIC_GAME';
                     workspaceDir = workerTaskWorkspaceDirFromAssignment(assignment);
-                    await pruneWorkerTaskWorkspaces(workspaceDir);
-                    await (0, promises_1.rm)(workspaceDir, { recursive: true, force: true });
-                    await (0, promises_1.mkdir)(workspaceDir, { recursive: true });
-                    const eventDir = node_path_1.default.join(workspaceDir, '.playdrop', 'task-events');
-                    await (0, promises_1.mkdir)(eventDir, { recursive: true });
-                    await stageWorkerTaskContext({
-                        workspaceDir,
-                        env,
-                        devPort,
-                        taskContext,
-                    });
-                    const binDir = await createLocalPlaydropShim({
+                    const preparedWorkspace = await prepareClaimedTaskWorkspace({
                         workspaceDir,
-                        taskId: taskContext.taskId,
-                        attempt: taskContext.attempt,
-                        devPort,
+                        attempt: task.attempts,
                     });
+                    if (preparedWorkspace.resumed) {
+                        console.log(`Agent task ${task.id} retry resumed retained workspace attempt ${task.attempts}.`);
+                    }
+                    agentWorkspaceDir = cleanRoom ? node_path_1.default.join(workspaceDir, 'project') : workspaceDir;
+                    await (0, promises_1.mkdir)(agentWorkspaceDir, { recursive: true });
+                    const eventDir = node_path_1.default.join(workspaceDir, '.playdrop', 'task-events');
+                    await (0, promises_1.mkdir)(eventDir, { recursive: true });
+                    if (!cleanRoom) {
+                        await stageWorkerTaskContext({
+                            workspaceDir,
+                            env,
+                            devPort,
+                            taskContext,
+                        });
+                    }
+                    const binDir = cleanRoom
+                        ? await createStaticGameCleanToolPath(workspaceDir, assignment.agent.runtime)
+                        : await createLocalPlaydropShim({
+                            workspaceDir,
+                            taskId: taskContext.taskId,
+                            attempt: taskContext.attempt,
+                            devPort,
+                        });
                     const handleEventDrainFailure = (error) => {
                         const classification = classifyWorkerEventDrainError(error);
                         if (classification === 'session_expired') {
@@ -4120,17 +4376,59 @@ async function startWorker(options = {}) {
                         appendObservedSkillPathsFromTranscript(chunks);
                         await appendWorkerTranscriptChunks({ client, taskId: task.id, workerKey, leaseToken, chunks });
                     };
-                    await stageAssignmentWorkspaceV2(workspaceDir, assignment.workspace);
-                    const assignmentPluginRoot = devPluginWorkingTree
-                        ? await stageAgentBundleWorkspaceFiles(devPluginWorkingTree, workspaceDir, task.kind)
+                    await stageAssignmentWorkspaceV2(agentWorkspaceDir, assignment.workspace);
+                    const assignmentPluginRoot = !cleanRoom
+                        && devPluginWorkingTree
+                        && !assignmentRequiresRegisteredBundle(assignment)
+                        ? await stageDevPluginWorkingTree({
+                            workingTree: devPluginWorkingTree,
+                            workspaceDir: agentWorkspaceDir,
+                            taskKind: task.kind,
+                        })
                         : assignment.plugin
                             ? await stageAssignmentPluginBundle({
-                                workspaceDir,
+                                workspaceDir: agentWorkspaceDir,
+                                extractionDir: workspaceDir,
                                 pluginBundle: assignment.plugin,
                                 taskKind: task.kind,
                             })
                             : null;
                     availableSkillPaths = listPluginSkillPaths(assignmentPluginRoot);
+                    if (cleanRoom) {
+                        const playdropMetadata = assignment.task.metadata.playdrop;
+                        const postAgentAction = playdropMetadata && typeof playdropMetadata === 'object' && !Array.isArray(playdropMetadata)
+                            ? playdropMetadata.postAgentAction
+                            : null;
+                        const publishInstruction = postAgentAction && typeof postAgentAction === 'object' && !Array.isArray(postAgentAction)
+                            ? postAgentAction
+                            : null;
+                        if (!assignment.plugin
+                            || assignmentPluginRoot !== null
+                            || assignment.agent.browser !== 'NONE'
+                            || publishInstruction?.type !== 'PUBLISH_STATIC_GAME'
+                            || publishInstruction.entryPoint !== 'index.html') {
+                            throw new Error('static_game_clean_room_contract_invalid');
+                        }
+                        availableSkillPaths = [];
+                        await client.workerCreateAgentTaskEvent(task.id, {
+                            workerKey,
+                            leaseToken,
+                            kind: 'system',
+                            phase: 'clean_room',
+                            message: 'Static game clean-room capability evidence recorded.',
+                            payload: {
+                                bundleHash: assignment.plugin.sha256,
+                                requestedModel: assignment.agent.model,
+                                resolvedModel: resolvedRuntimeModel,
+                                networkAccess: true,
+                                browser: assignment.agent.browser,
+                                availableSkills: [],
+                                pluginInstalled: false,
+                                playdropCliInPath: false,
+                                taskCredentialsExposed: false,
+                            },
+                        });
+                    }
                     heartbeatTimer = setInterval(() => {
                         client.workerHeartbeatAgentTask(task.id, { workerKey, leaseToken })
                             .then((heartbeat) => {
@@ -4189,81 +4487,161 @@ async function startWorker(options = {}) {
                             handleEventDrainFailure(error);
                         });
                     }, 1000);
-                    const prompt = assignment.request.prompt;
+                    const gameCreationTask = usesCreatorRecovery(task.kind);
+                    const startsInCreationRecovery = gameCreationTask && preparedWorkspace.resumed;
+                    const prompt = startsInCreationRecovery
+                        ? buildCreatorRecoveryPrompt({
+                            prompt: assignment.request.prompt,
+                            kind: task.kind,
+                        })
+                        : task.kind === 'GAME_EVAL' && preparedWorkspace.resumed
+                            ? buildGameEvalRetryPrompt(assignment.request.prompt)
+                            : assignment.request.prompt;
                     const imageAttachments = assignment.request.attachments
                         .filter((attachment) => attachment.contentType.startsWith('image/'))
                         .map((attachment) => ({
-                        path: resolveWorkspaceFileDestination(workspaceDir, attachment.path),
+                        path: resolveWorkspaceFileDestination(agentWorkspaceDir, attachment.path),
                         contentType: attachment.contentType,
                     }));
                     if (shuttingDown) {
                         throw new Error('worker_shutdown');
                     }
+                    const runAssignedAgent = async (input) => {
+                        if (assignment.agent.runtime === 'CODEX') {
+                            return runCodex({
+                                workspaceDir: agentWorkspaceDir,
+                                stateDir: cleanRoom ? workspaceDir : undefined,
+                                binDir,
+                                eventDir,
+                                prompt: input.prompt,
+                                envName: env,
+                                workerUsername: username,
+                                taskId: task.id,
+                                taskToken: assignment.task.token,
+                                attempt: taskContext.attempt,
+                                devPort,
+                                codexModel: codexModel ?? resolveCodexModel(assignment.agent.model),
+                                taskPluginRoot: assignmentPluginRoot,
+                                enablePlaywrightMcp: assignment.agent.browser === 'PLAYWRIGHT',
+                                instrumentSurface: resolveWorkerInstrumentSurface(taskContext),
+                                imagePaths: imageAttachments.map((attachment) => attachment.path),
+                                onTranscriptChunks: async (chunks) => {
+                                    await appendTranscriptChunks(chunks);
+                                },
+                                onChild: (controls) => {
+                                    activeTerminators.set(task.id, controls.terminate);
+                                },
+                                cleanRoom,
+                                timeoutMs: input.timeoutMs,
+                                resumeSessionId: input.resumeSessionId,
+                            });
+                        }
+                        if (assignment.agent.runtime === 'CLAUDE_CODE') {
+                            return runClaude({
+                                workspaceDir: agentWorkspaceDir,
+                                stateDir: cleanRoom ? workspaceDir : undefined,
+                                binDir,
+                                eventDir,
+                                prompt: input.prompt,
+                                enableChrome: assignment.agent.browser === 'CHROME',
+                                enablePlaywrightMcp: assignment.agent.browser === 'PLAYWRIGHT',
+                                instrumentSurface: resolveWorkerInstrumentSurface(taskContext),
+                                envName: env,
+                                workerUsername: username,
+                                taskId: task.id,
+                                taskToken: assignment.task.token,
+                                attempt: taskContext.attempt,
+                                devPort,
+                                claudeModel: claudeModel ?? resolveClaudeModel(assignment.agent.model),
+                                taskPluginRoot: assignmentPluginRoot,
+                                imageAttachments,
+                                onTranscriptChunks: async (chunks) => {
+                                    await appendTranscriptChunks(chunks);
+                                },
+                                onChild: (controls) => {
+                                    activeTerminators.set(task.id, controls.terminate);
+                                },
+                                cleanRoom,
+                                timeoutMs: input.timeoutMs,
+                                resumeSessionId: input.resumeSessionId,
+                            });
+                        }
+                        if (assignment.agent.runtime === 'CURSOR_COMPOSER') {
+                            await client.workerRecordAgentTaskAttemptUnavailable(task.id, {
+                                workerKey,
+                                leaseToken,
+                                attemptIndex: 0,
+                                reason: 'unavailable_runtime',
+                                message: 'Cursor Composer noninteractive worker execution is not configured on this worker.',
+                            });
+                            fenced = true;
+                            throw new Error('worker_cursor_composer_runner_not_configured');
+                        }
+                        throw new Error(`unsupported_worker_agent:${assignment.agent.runtime}`);
+                    };
                     agentStartedAt = new Date();
-                    if (assignment.agent.runtime === 'CODEX') {
-                        agentResult = await runCodex({
-                            workspaceDir,
-                            binDir,
-                            eventDir,
-                            prompt,
-                            envName: env,
-                            workerUsername: username,
-                            taskId: task.id,
-                            taskToken: assignment.task.token,
-                            attempt: taskContext.attempt,
-                            devPort,
-                            codexModel: codexModel ?? resolveCodexModel(assignment.agent.model),
-                            taskPluginRoot: assignmentPluginRoot,
-                            enablePlaywrightMcp: assignment.agent.browser === 'PLAYWRIGHT',
-                            instrumentSurface: resolveWorkerInstrumentSurface(taskContext),
-                            imagePaths: imageAttachments.map((attachment) => attachment.path),
-                            onTranscriptChunks: async (chunks) => {
-                                await appendTranscriptChunks(chunks);
-                            },
-                            onChild: (controls) => {
-                                activeTerminators.set(task.id, controls.terminate);
-                            },
-                        });
-                    }
-                    else if (assignment.agent.runtime === 'CLAUDE_CODE') {
-                        agentResult = await runClaude({
-                            workspaceDir,
-                            binDir,
-                            eventDir,
-                            prompt,
-                            enableChrome: assignment.agent.browser === 'CHROME',
-                            enablePlaywrightMcp: assignment.agent.browser === 'PLAYWRIGHT',
-                            instrumentSurface: resolveWorkerInstrumentSurface(taskContext),
-                            envName: env,
-                            workerUsername: username,
-                            taskId: task.id,
-                            taskToken: assignment.task.token,
-                            attempt: taskContext.attempt,
-                            devPort,
-                            claudeModel: claudeModel ?? resolveClaudeModel(assignment.agent.model),
-                            taskPluginRoot: assignmentPluginRoot,
-                            imageAttachments,
-                            onTranscriptChunks: async (chunks) => {
-                                await appendTranscriptChunks(chunks);
-                            },
-                            onChild: (controls) => {
-                                activeTerminators.set(task.id, controls.terminate);
-                            },
-                        });
-                    }
-                    else if (assignment.agent.runtime === 'CURSOR_COMPOSER') {
-                        await client.workerRecordAgentTaskAttemptUnavailable(task.id, {
+                    if (startsInCreationRecovery) {
+                        await client.workerCreateAgentTaskEvent(task.id, {
                             workerKey,
                             leaseToken,
-                            attemptIndex: 0,
-                            reason: 'unavailable_runtime',
-                            message: 'Cursor Composer noninteractive worker execution is not configured on this worker.',
+                            kind: 'progress',
+                            phase: 'creation_recovery',
+                            message: 'Resumed the retained game workspace with a focused creation recovery window.',
                         });
-                        fenced = true;
-                        throw new Error('worker_cursor_composer_runner_not_configured');
                     }
-                    else {
-                        throw new Error(`unsupported_worker_agent:${assignment.agent.runtime}`);
+                    agentResult = await runAssignedAgent({
+                        prompt,
+                        timeoutMs: startsInCreationRecovery
+                            ? runtime_1.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS
+                            : gameCreationTask
+                                ? runtime_1.DEFAULT_CREATOR_AGENT_TIMEOUT_MS
+                                : undefined,
+                    });
+                    if (startsInCreationRecovery && agentResult.timedOut) {
+                        const marker = 'agent_task_creation_recovery_timeout';
+                        agentResult = {
+                            ...agentResult,
+                            stderr: `${agentResult.stderr}\n${marker}`.trim(),
+                            outputTail: `${agentResult.outputTail}\n${marker}`.trim(),
+                        };
+                    }
+                    if (gameCreationTask
+                        && !startsInCreationRecovery
+                        && agentResult.timedOut
+                        && !fenced
+                        && !shuttingDown) {
+                        const timedOutResult = agentResult;
+                        const refreshedAfterTimeout = await fetchTaskDetail(client, target, task.id);
+                        if (refreshedAfterTimeout.task.status === 'RUNNING'
+                            && !hasAgentTaskUploadedArtifact(refreshedAfterTimeout.task)) {
+                            const providerSessionId = timedOutResult.providerSessionId?.trim() ?? '';
+                            if (!providerSessionId) {
+                                const marker = 'agent_task_resume_session_missing';
+                                agentResult = {
+                                    ...timedOutResult,
+                                    stderr: `${timedOutResult.stderr}\n${marker}`.trim(),
+                                    outputTail: `${timedOutResult.outputTail}\n${marker}`.trim(),
+                                };
+                            }
+                            else {
+                                await client.workerCreateAgentTaskEvent(task.id, {
+                                    workerKey,
+                                    leaseToken,
+                                    kind: 'progress',
+                                    phase: 'creation_recovery',
+                                    message: 'The one-hour creation ceiling was reached. Resuming the same agent conversation to finish the existing game.',
+                                });
+                                const recoveryResult = await runAssignedAgent({
+                                    prompt: buildCreatorRecoveryPrompt({
+                                        prompt: assignment.request.prompt,
+                                        kind: task.kind,
+                                    }),
+                                    timeoutMs: runtime_1.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS,
+                                    resumeSessionId: providerSessionId,
+                                });
+                                agentResult = mergeCreatorRecoveryResults(assignment.agent.runtime, timedOutResult, recoveryResult);
+                            }
+                        }
                     }
                     agentCompletedAt = new Date();
                     await queueEventDrain().catch((error) => {
@@ -4309,16 +4687,8 @@ async function startWorker(options = {}) {
                             await reportTelemetry(refreshed.task.status);
                         }
                         else if (hasAgentTaskUploadedArtifact(refreshed.task)) {
-                            retainWorkspace = true;
-                            console.error(`Agent task ${task.id} already uploaded an artifact but exited before task completion. Leaving it for manual completion repair.`);
-                            await client.workerCreateAgentTaskEvent(task.id, {
-                                workerKey,
-                                leaseToken,
-                                kind: 'progress',
-                                phase: 'upload',
-                                message: 'Agent exited after upload before task done; manual completion repair required.',
-                            });
-                            await reportTelemetry('RUNNING');
+                            console.error(`Agent task ${task.id} uploaded an artifact but exited before task completion; failing it explicitly.`);
+                            await failUploadedArtifactWithoutTaskDone();
                         }
                         else {
                             retainWorkspace = true;
@@ -4352,17 +4722,158 @@ async function startWorker(options = {}) {
                             console.error(`Agent task ${task.id} was finalized by the agent as ${refreshed.task.status}.`);
                             await reportTelemetry(refreshed.task.status);
                         }
-                        else if (hasAgentTaskUploadedArtifact(refreshed.task)) {
-                            retainWorkspace = true;
-                            console.error(`Agent task ${task.id} already uploaded an artifact but exited before task completion. Leaving it for manual completion repair.`);
-                            await client.workerCreateAgentTaskEvent(task.id, {
-                                workerKey,
-                                leaseToken,
-                                kind: 'progress',
-                                phase: 'upload',
-                                message: 'Agent exited after upload before task done; manual completion repair required.',
+                        else if (task.kind === 'STATIC_GAME') {
+                            const tokenCap = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_TOKEN_CAP', runtime_1.DEFAULT_WORKER_TOKEN_CAP);
+                            (0, runtime_1.assertWorkerTokenUsageWithinCap)({
+                                tokensUsed: agentResult.tokensUsed,
+                                tokenCap,
                             });
-                            await reportTelemetry('RUNNING');
+                            await reportTelemetry('DONE');
+                            try {
+                                let appId = refreshed.task.appId;
+                                let appVersionId = refreshed.task.appVersionId;
+                                let result;
+                                if (Number.isInteger(appId) && Number(appId) > 0
+                                    && Number.isInteger(appVersionId) && Number(appVersionId) > 0) {
+                                    result = {
+                                        appId,
+                                        appVersionId,
+                                        appName: refreshed.task.claimedAppName,
+                                        version: refreshed.task.outputVersion,
+                                        completedBy: 'worker_static_game_retry',
+                                    };
+                                    await client.workerCreateAgentTaskEvent(task.id, {
+                                        workerKey,
+                                        leaseToken,
+                                        kind: 'system',
+                                        phase: 'static_game_publish_retry',
+                                        message: 'Reused the static game version already linked to this task.',
+                                    });
+                                }
+                                else {
+                                    const primarySurface = resolveWorkerInstrumentSurface(taskContext);
+                                    if (!primarySurface) {
+                                        throw new Error('static_game_artifact_primary_surface_missing');
+                                    }
+                                    if (!agentWorkspaceDir) {
+                                        throw new Error('static_game_artifact_workspace_missing');
+                                    }
+                                    await client.workerCreateAgentTaskEvent(task.id, {
+                                        workerKey,
+                                        leaseToken,
+                                        kind: 'system',
+                                        phase: 'static_game_publish_started',
+                                        message: 'Publishing the clean-room static game output.',
+                                    });
+                                    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,
+                                        apiBase: envConfig.apiBase,
+                                        webBase: envConfig.webBase ?? null,
+                                        claimedAppName: refreshed.task.claimedAppName,
+                                        devRouterPort: devPort,
+                                        token,
+                                        user: me.user,
+                                    });
+                                    appId = published.appId;
+                                    appVersionId = published.appVersionId;
+                                    result = {
+                                        appId,
+                                        appVersionId,
+                                        appName: published.appName,
+                                        version: published.version,
+                                        versionNodeId: published.versionNodeId,
+                                        creatorUsername: published.creatorUsername,
+                                        sourceHash: published.sourceHash,
+                                        runtimeHash: published.runtimeHash,
+                                        playUrl: published.playUrl,
+                                        sourceContainsInjectedSdk: published.sourceContainsInjectedSdk,
+                                        runtimeContainsInjectedSdk: published.runtimeContainsInjectedSdk,
+                                        hostedLoadCheckPassed: published.hostedLoadCheckPassed,
+                                        versionVisibility: 'PRIVATE',
+                                        warnings: published.warnings,
+                                        completedBy: 'worker_static_game_publish',
+                                    };
+                                }
+                                if (!Number.isInteger(appId) || Number(appId) <= 0 || !Number.isInteger(appVersionId) || Number(appVersionId) <= 0) {
+                                    throw new Error('static_game_publish_linked_version_missing');
+                                }
+                                await client.workerCompleteAgentTask(task.id, {
+                                    workerKey,
+                                    leaseToken,
+                                    appId: Number(appId),
+                                    appVersionId: Number(appVersionId),
+                                    result,
+                                    summary: 'Created and privately hosted a standalone static web game.',
+                                    tokensUsed: agentResult.tokensUsed,
+                                });
+                                retainWorkspace = false;
+                                console.log(`Agent task ${task.id} published and completed as STATIC_GAME.`);
+                            }
+                            catch (error) {
+                                const rawMessage = error instanceof Error ? error.message : String(error);
+                                const artifactFailure = rawMessage.startsWith('static_game_artifact_');
+                                const failureCode = artifactFailure
+                                    ? rawMessage.split(':', 1)[0]
+                                    : 'static_game_publish_failed';
+                                await client.workerCreateAgentTaskEvent(task.id, {
+                                    workerKey,
+                                    leaseToken,
+                                    kind: 'system',
+                                    phase: artifactFailure ? 'static_game_artifact_failed' : 'static_game_publish_failed',
+                                    message: artifactFailure
+                                        ? `Static game output was invalid: ${rawMessage}`
+                                        : `Static game publishing failed: ${rawMessage}`,
+                                    payload: { error: failureCode, detail: rawMessage },
+                                });
+                                retainWorkspace = true;
+                                const terminalReason = artifactFailure
+                                    ? {
+                                        kind: 'failure',
+                                        category: 'upload_validation',
+                                        code: failureCode,
+                                        message: 'The static game output did not pass validation.',
+                                        retryable: false,
+                                        rawError: rawMessage,
+                                        source: 'worker',
+                                    }
+                                    : {
+                                        kind: 'failure',
+                                        category: 'instrument_error',
+                                        code: failureCode,
+                                        message: 'The platform failed to publish the static game.',
+                                        retryable: true,
+                                        rawError: rawMessage,
+                                        source: 'worker',
+                                    };
+                                await failTaskWithRetry(client, task.id, {
+                                    workerKey,
+                                    leaseToken,
+                                    error: failureCode,
+                                    terminalReason,
+                                    result: {
+                                        stage: artifactFailure ? 'artifact' : 'publish',
+                                        error: rawMessage,
+                                        agentRunSucceeded: true,
+                                    },
+                                });
+                            }
+                        }
+                        else if (hasAgentTaskUploadedArtifact(refreshed.task)) {
+                            console.error(`Agent task ${task.id} uploaded an artifact but exited before task completion; failing it explicitly.`);
+                            await failUploadedArtifactWithoutTaskDone();
                         }
                         else {
                             const tokenCap = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_TOKEN_CAP', runtime_1.DEFAULT_WORKER_TOKEN_CAP);
@@ -4716,6 +5227,9 @@ async function resolveTaskCommandContext(command, optionsEnv, taskContext) {
 }
 async function uploadTask(options = {}) {
     const taskContext = readTaskContextFile();
+    if (taskContext.kind === 'STATIC_GAME') {
+        throw new Error('task_upload_not_allowed_for_static_game');
+    }
     if (taskContext.kind === 'GAME_REVIEW' || taskContext.kind === 'GAME_EVAL') {
         throw new Error('task_upload_not_allowed_for_game_review');
     }
@@ -4828,6 +5342,7 @@ async function completeTask(options) {
     if (nextSteps === NEXT_STEPS_READ_FAILED) {
         return;
     }
+    const platformFeedback = readPlatformFeedbackFile(options.platformFeedbackFile);
     try {
         await ctx.client.workerCompleteAgentTask(taskContext.taskId, {
             taskToken: taskContext.taskToken,
@@ -4844,6 +5359,7 @@ async function completeTask(options) {
             },
             summary,
             ...(nextSteps !== undefined ? { nextSteps } : {}),
+            ...(platformFeedback ? { platformFeedback } : {}),
         });
     }
     catch (error) {
@@ -4858,6 +5374,7 @@ async function completeTask(options) {
                     appName: uploadResult.appName,
                     version: uploadResult.version,
                 },
+                ...(platformFeedback ? { platformFeedback } : {}),
             });
         }
         throw error;
@@ -4903,6 +5420,27 @@ function readOptionalTextFile(filePath) {
     const content = (0, node_fs_1.readFileSync)(resolved, 'utf8').trim();
     return content || null;
 }
+function readPlatformFeedbackFile(filePath) {
+    const normalizedPath = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalizedPath) {
+        return null;
+    }
+    try {
+        const resolved = node_path_1.default.resolve(normalizedPath);
+        if (!(0, node_fs_1.existsSync)(resolved)) {
+            throw new Error('file_missing');
+        }
+        const content = (0, node_fs_1.readFileSync)(resolved, 'utf8').trim();
+        if (!content || content.length > 10000) {
+            throw new Error(content ? 'file_too_long' : 'file_empty');
+        }
+        return content;
+    }
+    catch (error) {
+        console.warn(`Platform feedback was not attached: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
 function contentTypeForEvidenceFile(fileName) {
     const extension = node_path_1.default.extname(fileName).toLowerCase();
     if (extension === '.png')
@@ -4981,6 +5519,7 @@ async function submitReviewTask(options) {
     const creatorFeedback = state === 'ERROR'
         ? null
         : readOptionalTextFile(creatorFeedbackFile ?? undefined);
+    const platformFeedback = readPlatformFeedbackFile(options.platformFeedbackFile);
     await (0, review_1.validateGameReviewResult)({
         reviewState: state,
         reviewMessage,
@@ -5009,6 +5548,7 @@ async function submitReviewTask(options) {
         reviewState: state,
         reviewMessage,
         creatorFeedback,
+        ...(platformFeedback ? { platformFeedback } : {}),
         ...(nextSteps !== undefined ? { nextSteps } : {}),
         evidenceFiles,
         instrumentEvidence,
@@ -5136,11 +5676,13 @@ async function failTask(options) {
     if (!ctx) {
         return;
     }
+    const platformFeedback = readPlatformFeedbackFile(options.platformFeedbackFile);
     await ctx.client.workerFailAgentTask(taskContext.taskId, {
         taskToken: taskContext.taskToken,
         error: message,
         terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(message, 'agent'),
         result: { failedBy: 'agent' },
+        ...(platformFeedback ? { platformFeedback } : {}),
     });
     (0, output_1.printSuccess)('Task marked failed. This was the final operation; send one short final status sentence and stop immediately.');
 }