@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/commands/worker.js

@@ -3,34 +3,41 @@ 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_PROJECT_VALIDATE_NOT_ALLOWED_MESSAGE = exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = exports.WORKER_SESSION_EXPIRED_MESSAGE = exports.WORKSPACE_ARCHIVE_DOWNLOAD_TIMEOUT_MS = exports.runLoggedProcess = exports.readEnvBoolean = exports.readCodexSandboxMode = exports.readCodexRolloutTokenUsageForThread = exports.extractCodexTokensUsed = exports.extractGrokRunMetadata = 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.buildGrokExecArgs = exports.buildCodexExecArgs = exports.buildCleanRoomChildEnv = exports.buildClaudePermissionSettings = exports.buildClaudeExecArgs = exports.assertWorkerTokenUsageWithinCap = exports.extractZipArchive = void 0;
+exports.WORKER_TASK_WORKSPACE_RETENTION = exports.WORKER_CONTEXT_PROJECT_VALIDATE_NOT_ALLOWED_MESSAGE = exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = exports.WORKER_SESSION_EXPIRED_MESSAGE = exports.WORKSPACE_ARCHIVE_DOWNLOAD_TIMEOUT_MS = exports.runLoggedProcess = exports.readEnvBoolean = exports.readCodexRolloutTokenUsageForThread = exports.extractCodexTokensUsed = exports.extractGrokRunMetadata = exports.extractCodexThreadId = exports.extractClaudeSessionId = exports.extractCodexRolloutTokenUsage = exports.extractAgentTokenUsage = exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = exports.DEFAULT_CODEX_TIMEOUT_MS = exports.buildWorkerChildEnv = exports.buildPlaywrightMcpCommand = exports.buildGrokExecArgs = exports.buildCodexExecArgs = exports.buildCleanRoomChildEnv = exports.buildClaudePermissionSettings = exports.buildClaudeExecArgs = exports.extractZipArchive = void 0;
 exports.usesCreatorRecovery = usesCreatorRecovery;
 exports.buildDeterministicReleaseSmokeArtifact = buildDeterministicReleaseSmokeArtifact;
 exports.buildCreatorRecoveryPrompt = buildCreatorRecoveryPrompt;
+exports.buildMissingAgentOutcomeRecoveryPrompt = buildMissingAgentOutcomeRecoveryPrompt;
+exports.shouldRecoverMissingAgentOutcome = shouldRecoverMissingAgentOutcome;
+exports.missingAgentOutcomeTerminalReason = missingAgentOutcomeTerminalReason;
+exports.creationTimeoutTerminalReason = creationTimeoutTerminalReason;
 exports.buildGameEvalRetryPrompt = buildGameEvalRetryPrompt;
 exports.resolveInitialCreatorProgress = resolveInitialCreatorProgress;
 exports.allocateWorkerDevPort = allocateWorkerDevPort;
 exports.isWorkerContextCommandAllowed = isWorkerContextCommandAllowed;
 exports.resolveWorkerContextCommandBlockMessage = resolveWorkerContextCommandBlockMessage;
 exports.resolveWorkerExecutionTargetFromRole = resolveWorkerExecutionTargetFromRole;
-exports.normalizeWorkerTaskAssignmentV2 = normalizeWorkerTaskAssignmentV2;
-exports.normalizeWorkerTaskAssignmentV3 = normalizeWorkerTaskAssignmentV3;
-exports.normalizeWorkerClaimResponseV3 = normalizeWorkerClaimResponseV3;
+exports.normalizeWorkerGameTaskAssignment = normalizeWorkerGameTaskAssignment;
+exports.normalizeWorkerClaimResponseV5 = normalizeWorkerClaimResponseV5;
 exports.nextClaimBackoffMs = nextClaimBackoffMs;
 exports.claimBackoffDelayMs = claimBackoffDelayMs;
 exports.acknowledgeWorkerTaskClaim = acknowledgeWorkerTaskClaim;
 exports.containWorkerTaskRun = containWorkerTaskRun;
 exports.resolveWorkerHomeDir = resolveWorkerHomeDir;
+exports.configureWorkerFal = configureWorkerFal;
 exports.pruneWorkerTaskWorkspaces = pruneWorkerTaskWorkspaces;
 exports.prepareClaimedTaskWorkspace = prepareClaimedTaskWorkspace;
 exports.buildWorkerTaskContextV2 = buildWorkerTaskContextV2;
 exports.resolveWorkerInstrumentSurface = resolveWorkerInstrumentSurface;
 exports.hasAgentTaskUploadedArtifact = hasAgentTaskUploadedArtifact;
-exports.appendWorkerTranscriptChunks = appendWorkerTranscriptChunks;
+exports.buildWorkerTranscriptUploadHeaders = buildWorkerTranscriptUploadHeaders;
+exports.describeTaskUploadFailure = describeTaskUploadFailure;
+exports.recordTaskUploadFailure = recordTaskUploadFailure;
+exports.readTaskUploadFailureFile = readTaskUploadFailureFile;
+exports.readTaskUploadResultFile = readTaskUploadResultFile;
 exports.readTaskNextStepsFile = readTaskNextStepsFile;
 exports.assertTaskUploadResultMatchesContext = assertTaskUploadResultMatchesContext;
-exports.stageAssignmentWorkspaceV2 = stageAssignmentWorkspaceV2;
-exports.stageAssignmentWorkspaceV3 = stageAssignmentWorkspaceV3;
+exports.stageAssignmentWorkspace = stageAssignmentWorkspace;
 exports.assertAssignmentPluginBundleExtractionBounds = assertAssignmentPluginBundleExtractionBounds;
 exports.stageDevPluginWorkingTree = stageDevPluginWorkingTree;
 exports.stageAssignmentPluginBundle = stageAssignmentPluginBundle;
@@ -61,16 +68,21 @@ exports.buildGrokPromptJson = buildGrokPromptJson;
 exports.buildGrokIsolationEnv = buildGrokIsolationEnv;
 exports.resolveHostGrokAuthPath = resolveHostGrokAuthPath;
 exports.mergeCreatorRecoveryResults = mergeCreatorRecoveryResults;
+exports.mergeMissingAgentOutcomeRecoveryResults = mergeMissingAgentOutcomeRecoveryResults;
 exports.buildAgentFailureCode = buildAgentFailureCode;
 exports.classifyAgentAvailabilityFailureReason = classifyAgentAvailabilityFailureReason;
 exports.describeAgentFailureForEvent = describeAgentFailureForEvent;
+exports.normalizeWorkerFailureErrorCode = normalizeWorkerFailureErrorCode;
 exports.createLocalPlaydropShim = createLocalPlaydropShim;
 exports.parseCodexModelCatalog = parseCodexModelCatalog;
+exports.codexFeatureEnabled = codexFeatureEnabled;
 exports.parseClaudeModelCatalog = parseClaudeModelCatalog;
 exports.claudeModelProbeReportsSelection = claudeModelProbeReportsSelection;
 exports.parseGrokModelCatalog = parseGrokModelCatalog;
 exports.probeWorkerProviderIndependently = probeWorkerProviderIndependently;
 exports.describeWorkerPreflightReason = describeWorkerPreflightReason;
+exports.falAuthenticationProbeExitCode = falAuthenticationProbeExitCode;
+exports.probeFalAuthentication = probeFalAuthentication;
 exports.buildWorkerSetupActions = buildWorkerSetupActions;
 exports.resolveWorkerStateDir = resolveWorkerStateDir;
 exports.resolveWorkerSupervisorLockFile = resolveWorkerSupervisorLockFile;
@@ -90,6 +102,8 @@ exports.assertLaunchAgentPlistCompatible = assertLaunchAgentPlistCompatible;
 exports.launchManagedWorker = launchManagedWorker;
 exports.showWorkerStatus = showWorkerStatus;
 exports.setupWorker = setupWorker;
+exports.completeWorkerAgentTaskWithRetry = completeWorkerAgentTaskWithRetry;
+exports.classifyWorkerSupervisorFailure = classifyWorkerSupervisorFailure;
 exports.assignmentRequiresRegisteredBundle = assignmentRequiresRegisteredBundle;
 exports.startWorker = startWorker;
 exports.reportTask = reportTask;
@@ -126,16 +140,21 @@ const config_1 = require("../config");
 const messages_1 = require("../messages");
 const output_1 = require("../output");
 const shellProbe_1 = require("../shellProbe");
+const taskSelection_1 = require("../taskSelection");
 const review_1 = require("./review");
 const upload_1 = require("./upload");
+const staticHtml_1 = require("../apps/staticHtml");
 const runtime_1 = require("./worker/runtime");
 const instrument_evidence_1 = require("./worker/instrument-evidence");
 const provider_telemetry_1 = require("./worker/provider-telemetry");
 const archive_staging_1 = require("./worker/archive-staging");
+const game_server_infra_1 = require("./worker/game-server-infra");
+const game_source_git_1 = require("./worker/game-source-git");
+const generation_1 = require("./worker/generation");
+const e2e_fixtures_1 = require("./worker/e2e-fixtures");
 var archive_staging_2 = require("./worker/archive-staging");
 Object.defineProperty(exports, "extractZipArchive", { enumerable: true, get: function () { return archive_staging_2.extractZipArchive; } });
 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; } });
@@ -146,7 +165,6 @@ Object.defineProperty(exports, "buildWorkerChildEnv", { enumerable: true, get: f
 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; } });
@@ -154,7 +172,6 @@ Object.defineProperty(exports, "extractCodexThreadId", { enumerable: true, get:
 Object.defineProperty(exports, "extractGrokRunMetadata", { enumerable: true, get: function () { return runtime_2.extractGrokRunMetadata; } });
 Object.defineProperty(exports, "extractCodexTokensUsed", { enumerable: true, get: function () { return runtime_2.extractCodexTokensUsed; } });
 Object.defineProperty(exports, "readCodexRolloutTokenUsageForThread", { enumerable: true, get: function () { return runtime_2.readCodexRolloutTokenUsageForThread; } });
-Object.defineProperty(exports, "readCodexSandboxMode", { enumerable: true, get: function () { return runtime_2.readCodexSandboxMode; } });
 Object.defineProperty(exports, "readEnvBoolean", { enumerable: true, get: function () { return runtime_2.readEnvBoolean; } });
 Object.defineProperty(exports, "runLoggedProcess", { enumerable: true, get: function () { return runtime_2.runLoggedProcess; } });
 const DEFAULT_POLL_INTERVAL_MS = 1000;
@@ -171,8 +188,7 @@ const FAIL_REPORT_RETRY_DELAY_MS = 2000;
 const CLAIM_ACK_RETRY_DELAY_MS = 500;
 const CLAIM_ACK_MAX_ATTEMPTS = 4;
 exports.WORKSPACE_ARCHIVE_DOWNLOAD_TIMEOUT_MS = 5 * 60000;
-const WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE = 100;
-const WORKER_WRAPPER_CONTRACT_VERSION = 3;
+const WORKER_WRAPPER_CONTRACT_VERSION = 5;
 const WORKER_SUPPORTED_KINDS = [
     "NEW_GAME",
     "STATIC_GAME",
@@ -181,6 +197,14 @@ const WORKER_SUPPORTED_KINDS = [
     "GAME_REVIEW",
     "GAME_EVAL",
     "RELEASE_SMOKE",
+    "TEXT",
+    "JSON",
+    "IMAGE",
+    "MODEL_3D",
+    "VIDEO",
+    "SFX",
+    "SPEECH",
+    "MUSIC",
 ];
 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"]);
@@ -222,6 +246,46 @@ function buildCreatorRecoveryPrompt(input) {
         `Original request: ${prompt}`,
     ].join("\n\n");
 }
+function buildMissingAgentOutcomeRecoveryPrompt(kind) {
+    if (kind === "STATIC_GAME" || kind === "RELEASE_SMOKE") {
+        throw new Error(`agent_task_outcome_recovery_unsupported:${kind}`);
+    }
+    return [
+        "You stopped without reporting task success or failure.",
+        "Please read the task-worker skill, resume your work in this same task and conversation, and report failure or success before you exit.",
+    ].join(" ");
+}
+function shouldRecoverMissingAgentOutcome(input) {
+    return (input.kind !== "STATIC_GAME" &&
+        input.kind !== "RELEASE_SMOKE" &&
+        input.taskStatus === "RUNNING" &&
+        !input.completionReported &&
+        input.result.exitCode === 0 &&
+        input.result.signal === null &&
+        !input.result.timedOut);
+}
+function missingAgentOutcomeTerminalReason() {
+    const code = "agent_stopped_without_outcome";
+    return {
+        kind: "failure",
+        category: "agent_failure",
+        code,
+        message: "The agent stopped without being able to upload the game. Please retry.",
+        retryable: true,
+        source: "worker",
+    };
+}
+function creationTimeoutTerminalReason() {
+    const code = "agent_task_creation_timeout";
+    return {
+        kind: "failure",
+        category: "provider_timeout",
+        code,
+        message: "The task took too long and couldn't finish on time. Retry it, or clear it and ask for a simpler change.",
+        retryable: true,
+        source: "worker",
+    };
+}
 function buildGameEvalRetryPrompt(prompt) {
     return [
         prompt,
@@ -263,12 +327,36 @@ const WORKER_CONTEXT_ALLOWED_COMMANDS = [
     ["documentation", "read"],
     ["help"],
     ["ai", "create"],
-    ["ai", "jobs", "browse"],
-    ["ai", "jobs", "detail"],
+    ["ai", "tasks", "browse"],
+    ["chat", "channels"],
+    ["chat", "inbox"],
+    ["chat", "conversation"],
+    ["chat", "read"],
+    ["chat", "thread"],
+    ["chat", "send"],
+    ["chat", "reply"],
+    ["chat", "dm"],
+    ["chat", "react"],
+    ["chat", "unreact"],
+    ["ai", "tasks", "detail"],
     ["ai", "generations"],
 ];
 exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task asset-runtime, task claim-slug, task upload/done/fail, assigned app scaffolding, project build/dev/check/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
 exports.WORKER_CONTEXT_PROJECT_VALIDATE_NOT_ALLOWED_MESSAGE = 'worker_context_project_validate_not_allowed: "playdrop project validate" is not available inside a PlayDrop worker task. Run "playdrop task upload --preflight-only" as the sole pre-upload validation gate.';
+const TASK_UPLOAD_FAILURE_CATEGORIES = new Set([
+    "provider_capacity",
+    "provider_connection",
+    "provider_timeout",
+    "instrument_error",
+    "upload_validation",
+    "agent_failure",
+]);
+const TASK_UPLOAD_FAILURE_SOURCES = new Set([
+    "worker",
+    "agent",
+    "provider",
+    "instrument",
+]);
 function resolveInitialCreatorProgress(kind, creationRecovery = false) {
     if (creationRecovery) {
         return null;
@@ -395,7 +483,13 @@ function isAssignedAppScaffoldCommandAllowed(argv) {
     return normalizeRemixFlagValue(argv) === context.remixSourceRef;
 }
 function resolveWorkerExecutionTargetFromRole(role) {
-    return role === "ADMIN" ? "FIRST_PARTY" : "PERSONAL";
+    if (role === "CLOUD_WORKER") {
+        return "FIRST_PARTY";
+    }
+    if (role === "CREATOR") {
+        return "PERSONAL";
+    }
+    throw new Error(`worker_role_not_supported:${String(role ?? "unknown")}`);
 }
 function normalizeAssignmentWorkspaceFolder(value) {
     const folderName = typeof value === "string" ? value.trim() : "";
@@ -439,138 +533,6 @@ function normalizeAssignmentContent(input) {
     }
     return { path: relativePath, contentBase64, sha256, sizeBytes, buffer };
 }
-function normalizeWorkerTaskAssignmentV2(claim) {
-    if (claim.protocolVersion !== 2) {
-        throw new Error("agent_task_claim_protocol_version_mismatch");
-    }
-    if (claim.action !== "run") {
-        return null;
-    }
-    const assignment = claim.assignment;
-    const taskId = parsePositiveInteger(assignment.task.id, "agent_task_assignment_task_id_missing");
-    const taskToken = typeof assignment.task.token === "string" ? assignment.task.token.trim() : "";
-    const taskType = typeof assignment.task.type === "string" ? assignment.task.type.trim() : "";
-    const attempt = parsePositiveInteger(assignment.task.attempt, "agent_task_assignment_attempt_missing");
-    const prompt = typeof assignment.request.prompt === "string" ? assignment.request.prompt : "";
-    const model = typeof assignment.agent.model === "string" ? assignment.agent.model.trim() : "";
-    if (!taskToken || !taskType || !prompt.trim() || !model) {
-        throw new Error("agent_task_assignment_invalid");
-    }
-    const workspacePaths = new Set();
-    const files = assignment.workspace.files.map((file) => {
-        const normalized = normalizeAssignmentContent({
-            path: file.path,
-            contentBase64: file.contentBase64,
-            sha256: file.sha256,
-            sizeBytes: file.sizeBytes,
-            code: "agent_task_assignment_workspace_file",
-        });
-        const contentType = typeof file.contentType === "string" ? file.contentType.trim() : "";
-        if (!contentType) {
-            throw new Error("agent_task_assignment_workspace_file_content_type_missing");
-        }
-        if (workspacePaths.has(normalized.path)) {
-            throw new Error("agent_task_assignment_workspace_path_duplicate");
-        }
-        workspacePaths.add(normalized.path);
-        return {
-            path: normalized.path,
-            sha256: normalized.sha256,
-            sizeBytes: normalized.sizeBytes,
-            contentType,
-            contentBase64: normalized.contentBase64,
-        };
-    });
-    const archives = assignment.workspace.archives.map((archive) => {
-        if (archive.format !== "zip") {
-            throw new Error("agent_task_assignment_workspace_archive_format_invalid");
-        }
-        const normalized = normalizeAssignmentContent({
-            path: archive.path,
-            contentBase64: archive.contentBase64,
-            sha256: archive.sha256,
-            sizeBytes: archive.sizeBytes,
-            code: "agent_task_assignment_workspace_archive",
-        });
-        if (workspacePaths.has(normalized.path)) {
-            throw new Error("agent_task_assignment_workspace_path_duplicate");
-        }
-        workspacePaths.add(normalized.path);
-        return {
-            path: normalized.path,
-            format: "zip",
-            sha256: normalized.sha256,
-            sizeBytes: normalized.sizeBytes,
-            contentBase64: normalized.contentBase64,
-        };
-    });
-    const fileByPath = new Map(files.map((file) => [file.path, file]));
-    const attachmentIds = new Set();
-    const attachments = assignment.request.attachments.map((attachment) => {
-        const id = typeof attachment.id === "string" ? attachment.id.trim() : "";
-        const attachmentPath = normalizeAssignmentWorkspaceRelativePath(attachment.path);
-        const fileName = typeof attachment.fileName === "string" ? attachment.fileName.trim() : "";
-        const contentType = typeof attachment.contentType === "string" ? attachment.contentType.trim() : "";
-        const sha256 = typeof attachment.sha256 === "string" ? attachment.sha256.trim() : "";
-        const sizeBytes = Number(attachment.sizeBytes);
-        const file = fileByPath.get(attachmentPath);
-        if (!id || attachmentIds.has(id) || !fileName || !contentType || !file) {
-            throw new Error("agent_task_assignment_attachment_invalid");
-        }
-        if (sha256 !== file.sha256 || sizeBytes !== file.sizeBytes || contentType !== file.contentType) {
-            throw new Error("agent_task_assignment_attachment_metadata_mismatch");
-        }
-        attachmentIds.add(id);
-        return {
-            id,
-            path: attachmentPath,
-            fileName,
-            contentType,
-            sizeBytes,
-            sha256,
-            description: typeof attachment.description === "string" ? attachment.description : null,
-        };
-    });
-    for (const attachment of attachments) {
-        if (!fileByPath.has(attachment.path)) {
-            throw new Error("agent_task_assignment_attachment_file_missing");
-        }
-    }
-    const browser = assignment.agent.browser;
-    if (browser !== "NONE" && browser !== "CHROME" && browser !== "PLAYWRIGHT") {
-        throw new Error("agent_task_assignment_browser_invalid");
-    }
-    const reasoningEffort = assignment.agent.reasoningEffort;
-    if (reasoningEffort !== null && typeof reasoningEffort !== "string") {
-        throw new Error("agent_task_assignment_reasoning_effort_invalid");
-    }
-    return {
-        task: {
-            id: taskId,
-            token: taskToken,
-            type: taskType,
-            executionTarget: normalizeAssignmentTarget(assignment.task.executionTarget),
-            attempt,
-            metadata: assignment.task.metadata,
-        },
-        workspace: {
-            folderName: normalizeAssignmentWorkspaceFolder(assignment.workspace.folderName),
-            archives,
-            files,
-        },
-        plugin: assignment.plugin,
-        request: {
-            prompt,
-            attachments,
-        },
-        agent: {
-            runtime: normalizeAssignmentAgent(assignment.agent.runtime),
-            model,
-            reasoningEffort,
-            browser,
-        },
-    };
-}
 function requireClaimRecord(value, code = "agent_task_claim_response_malformed") {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error(code);
@@ -616,33 +578,168 @@ function normalizeWorkspaceArchiveDownloadUrl(value) {
     }
     return parsed.toString();
 }
-function normalizeWorkerTaskAssignmentV3(claim) {
-    const response = requireClaimRecord(claim);
-    if (response.protocolVersion !== 3) {
-        throw new Error("agent_task_claim_protocol_version_mismatch");
-    }
-    if (response.action === "idle" || response.action === "quiesce_for_update") {
-        if (response.assignment !== null || response.lease !== null) {
-            throw new Error("agent_task_claim_response_malformed");
+function normalizeGameSourceAssignment(value) {
+    if (value === undefined)
+        return undefined;
+    const source = requireClaimRecord(value, "agent_task_assignment_game_source_invalid");
+    if (source.version !== 2 || !["NEW", "STATIC", "REMIX", "UPDATE"].includes(String(source.mode))) {
+        throw new Error("agent_task_assignment_game_source_invalid");
+    }
+    const normalizeVersions = (entries) => {
+        if (!Array.isArray(entries))
+            throw new Error("agent_task_assignment_game_source_invalid");
+        return entries.map((entry) => {
+            const item = requireClaimRecord(entry, "agent_task_assignment_game_source_invalid");
+            const versionId = parsePositiveInteger(item.versionId, "agent_task_assignment_game_source_invalid");
+            const major = Number(item.major);
+            const minor = Number(item.minor);
+            const patch = Number(item.patch);
+            const commitSha = String(item.commitSha ?? "").trim().toLowerCase();
+            if ([major, minor, patch].some((part) => !Number.isSafeInteger(part) || part < 0) || !/^[0-9a-f]{40}$/.test(commitSha)) {
+                throw new Error("agent_task_assignment_game_source_invalid");
+            }
+            return { versionId, major, minor, patch, commitSha };
+        });
+    };
+    const authoritativeVersions = normalizeVersions(source.authoritativeVersions);
+    if (!Array.isArray(source.transcripts)) {
+        throw new Error("agent_task_assignment_game_source_invalid");
+    }
+    const transcripts = source.transcripts.map((entry) => {
+        const item = requireClaimRecord(entry, "agent_task_assignment_game_source_invalid");
+        const taskId = parsePositiveInteger(item.taskId, "agent_task_assignment_game_source_invalid");
+        const attempt = parsePositiveInteger(item.attempt, "agent_task_assignment_game_source_invalid");
+        const sha256 = String(item.sha256 ?? "").trim().toLowerCase();
+        const bytes = Number(item.bytes);
+        if (!/^[0-9a-f]{64}$/.test(sha256) || !Number.isSafeInteger(bytes) || bytes < 0) {
+            throw new Error("agent_task_assignment_game_source_invalid");
         }
-        return null;
-    }
-    if (response.action !== "run") {
-        throw new Error("agent_task_claim_response_malformed");
-    }
-    const assignment = requireClaimRecord(response.assignment, "agent_task_assignment_invalid");
+        return {
+            taskId,
+            attempt,
+            downloadUrl: normalizeWorkspaceArchiveDownloadUrl(item.downloadUrl),
+            sha256,
+            bytes,
+        };
+    });
+    const listingObject = source.listingSync === null
+        ? null
+        : requireClaimRecord(source.listingSync, "agent_task_assignment_game_source_invalid");
+    const listingSync = listingObject
+        ? (() => {
+            const stringOrNull = (value) => {
+                if (value === null)
+                    return null;
+                if (typeof value !== "string")
+                    throw new Error("agent_task_assignment_game_source_invalid");
+                return value;
+            };
+            const stringArray = (value) => {
+                if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+                    throw new Error("agent_task_assignment_game_source_invalid");
+                }
+                return value;
+            };
+            if (!Array.isArray(listingObject.files) || typeof listingObject.updatedAt !== "string" || !Number.isFinite(Date.parse(listingObject.updatedAt))) {
+                throw new Error("agent_task_assignment_game_source_invalid");
+            }
+            const files = listingObject.files.map((entry) => {
+                const item = requireClaimRecord(entry, "agent_task_assignment_game_source_invalid");
+                const filePath = typeof item.path === "string" ? item.path.trim() : "";
+                const fileSha256 = String(item.sha256 ?? "").trim().toLowerCase();
+                const fileBytes = Number(item.bytes);
+                if (!filePath.startsWith("listing/") || !/^[0-9a-f]{64}$/.test(fileSha256) || !Number.isSafeInteger(fileBytes) || fileBytes < 0) {
+                    throw new Error("agent_task_assignment_game_source_invalid");
+                }
+                return {
+                    path: filePath,
+                    downloadUrl: normalizeWorkspaceArchiveDownloadUrl(item.downloadUrl),
+                    sha256: fileSha256,
+                    bytes: fileBytes,
+                };
+            });
+            const version = String(listingObject.version ?? "").trim();
+            if (!/^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/.test(version)) {
+                throw new Error("agent_task_assignment_game_source_invalid");
+            }
+            return {
+                versionId: parsePositiveInteger(listingObject.versionId, "agent_task_assignment_game_source_invalid"),
+                version,
+                displayName: stringOrNull(listingObject.displayName),
+                subtitle: stringOrNull(listingObject.subtitle),
+                description: stringOrNull(listingObject.description),
+                iconPath: stringOrNull(listingObject.iconPath),
+                heroPortraitPath: stringOrNull(listingObject.heroPortraitPath),
+                heroLandscapePath: stringOrNull(listingObject.heroLandscapePath),
+                socialLandscapePath: stringOrNull(listingObject.socialLandscapePath),
+                screenshotsPortrait: stringArray(listingObject.screenshotsPortrait),
+                screenshotsLandscape: stringArray(listingObject.screenshotsLandscape),
+                videosPortrait: stringArray(listingObject.videosPortrait),
+                videosLandscape: stringArray(listingObject.videosLandscape),
+                updatedAt: listingObject.updatedAt,
+                files,
+            };
+        })()
+        : null;
+    const selectedBaseVersionId = source.selectedBaseVersionId === null
+        ? null
+        : parsePositiveInteger(source.selectedBaseVersionId, "agent_task_assignment_game_source_invalid");
+    const baseObject = source.baseRepository === null
+        ? null
+        : requireClaimRecord(source.baseRepository, "agent_task_assignment_game_source_invalid");
+    const baseRepository = baseObject
+        ? {
+            appId: parsePositiveInteger(baseObject.appId, "agent_task_assignment_game_source_invalid"),
+            repoGeneration: String(baseObject.repoGeneration ?? "").trim(),
+            bundleDownloadUrl: normalizeWorkspaceArchiveDownloadUrl(baseObject.bundleDownloadUrl),
+            expectedHeadSha: String(baseObject.expectedHeadSha ?? "").trim().toLowerCase(),
+            selectedCommitSha: String(baseObject.selectedCommitSha ?? "").trim().toLowerCase(),
+        }
+        : null;
+    const targetObject = requireClaimRecord(source.targetRepository, "agent_task_assignment_game_source_invalid");
+    const targetRepository = {
+        appId: targetObject.appId === null
+            ? null
+            : parsePositiveInteger(targetObject.appId, "agent_task_assignment_game_source_invalid"),
+        repoGeneration: targetObject.repoGeneration === null ? null : String(targetObject.repoGeneration).trim(),
+        expectedHeadSha: targetObject.expectedHeadSha === null ? null : String(targetObject.expectedHeadSha).trim().toLowerCase(),
+    };
+    if ((baseRepository && (!/^[1-9][0-9]*$/.test(baseRepository.repoGeneration) ||
+        !/^[0-9a-f]{40}$/.test(baseRepository.expectedHeadSha) ||
+        !/^[0-9a-f]{40}$/.test(baseRepository.selectedCommitSha))) ||
+        ((source.mode === "UPDATE" || source.mode === "REMIX") && baseRepository === null) ||
+        ((source.mode === "NEW" || source.mode === "STATIC") && baseRepository !== null) ||
+        (targetRepository.repoGeneration !== null && !/^[1-9][0-9]*$/.test(targetRepository.repoGeneration)) ||
+        (targetRepository.expectedHeadSha !== null && !/^[0-9a-f]{40}$/.test(targetRepository.expectedHeadSha)) ||
+        ((targetRepository.repoGeneration === null) !== (targetRepository.expectedHeadSha === null)))
+        throw new Error("agent_task_assignment_game_source_invalid");
+    return {
+        version: 2,
+        mode: source.mode,
+        baseRepository,
+        targetRepository,
+        authoritativeVersions,
+        selectedBaseVersionId,
+        transcripts,
+        listingSync,
+    };
+}
+function normalizeWorkerGameTaskAssignment(value) {
+    const assignment = requireClaimRecord(value, "agent_task_assignment_invalid");
     const task = requireClaimRecord(assignment.task, "agent_task_assignment_invalid");
     const workspace = requireClaimRecord(assignment.workspace, "agent_task_assignment_workspace_missing");
     const request = requireClaimRecord(assignment.request, "agent_task_assignment_invalid");
     const agent = requireClaimRecord(assignment.agent, "agent_task_assignment_invalid");
     const taskId = parsePositiveInteger(task.id, "agent_task_assignment_task_id_missing");
     const taskToken = typeof task.token === "string" ? task.token.trim() : "";
+    const taskAccessToken = typeof task.accessToken === "string" ? task.accessToken.trim() : "";
     const taskType = typeof task.type === "string" ? task.type.trim() : "";
     const attempt = parsePositiveInteger(task.attempt, "agent_task_assignment_attempt_missing");
     const prompt = typeof request.prompt === "string" ? request.prompt : "";
     const model = typeof agent.model === "string" ? agent.model.trim() : "";
     const metadata = requireClaimRecord(task.metadata, "agent_task_assignment_metadata_invalid");
-    if (!taskToken || !taskType || !prompt.trim() || !model) {
+    const executionTarget = normalizeAssignmentTarget(task.executionTarget);
+    if (!taskToken || !taskType || !prompt.trim() || !model || (executionTarget === "FIRST_PARTY" && !taskAccessToken)) {
         throw new Error("agent_task_assignment_invalid");
     }
     if (!Array.isArray(workspace.files) || !Array.isArray(workspace.archives) || !Array.isArray(request.attachments)) {
@@ -678,7 +775,11 @@ function normalizeWorkerTaskAssignmentV3(claim) {
         const archive = requireClaimRecord(value, "agent_task_assignment_workspace_archive_invalid");
         const archivePath = normalizeAssignmentWorkspaceRelativePath(archive.path);
         const sizeBytes = Number(archive.sizeBytes);
-        if (archive.format !== "zip" || !Number.isInteger(sizeBytes) || sizeBytes <= 0) {
+        const sha256 = typeof archive.sha256 === "string" ? archive.sha256.trim().toLowerCase() : "";
+        if (archive.format !== "zip" ||
+            !Number.isInteger(sizeBytes) ||
+            sizeBytes <= 0 ||
+            !/^[0-9a-f]{64}$/.test(sha256)) {
             throw new Error("agent_task_assignment_workspace_archive_metadata_invalid");
         }
         if (workspacePaths.has(archivePath)) {
@@ -690,6 +791,7 @@ function normalizeWorkerTaskAssignmentV3(claim) {
             format: "zip",
             downloadUrl: normalizeWorkspaceArchiveDownloadUrl(archive.downloadUrl),
             sizeBytes,
+            sha256,
         };
     });
     const fileByPath = new Map(files.map((file) => [file.path, file]));
@@ -728,12 +830,17 @@ function normalizeWorkerTaskAssignmentV3(claim) {
     if (reasoningEffort !== null && typeof reasoningEffort !== "string") {
         throw new Error("agent_task_assignment_reasoning_effort_invalid");
     }
+    const gameSource = normalizeGameSourceAssignment(assignment.gameSource);
+    if (gameSource && executionTarget !== "FIRST_PARTY") {
+        throw new Error("agent_task_assignment_game_source_invalid");
+    }
     return {
         task: {
             id: taskId,
             token: taskToken,
+            ...(taskAccessToken ? { accessToken: taskAccessToken } : {}),
             type: taskType,
-            executionTarget: normalizeAssignmentTarget(task.executionTarget),
+            executionTarget,
             attempt,
             metadata,
         },
@@ -750,38 +857,103 @@ function normalizeWorkerTaskAssignmentV3(claim) {
             reasoningEffort,
             browser,
         },
+        gameSource,
     };
 }
-function normalizeWorkerClaimResponseV3(value) {
+function normalizeWorkerClaimResponseV5(value) {
     const response = requireClaimRecord(value);
-    const assignment = normalizeWorkerTaskAssignmentV3(response);
+    if (response.protocolVersion !== 5)
+        throw new Error("agent_task_claim_protocol_version_mismatch");
     const updatePolicy = response.updatePolicy;
     if (updatePolicy !== null && (typeof updatePolicy !== "object" || Array.isArray(updatePolicy))) {
         throw new Error("agent_task_claim_response_malformed");
     }
     if (response.action === "idle" || response.action === "quiesce_for_update") {
+        if (response.assignment !== null || response.lease !== null)
+            throw new Error("agent_task_claim_response_malformed");
         return {
-            protocolVersion: 3,
+            protocolVersion: 5,
             action: response.action,
             assignment: null,
             lease: null,
             updatePolicy: updatePolicy,
         };
     }
-    if (!assignment) {
-        throw new Error("agent_task_claim_missing_assignment");
+    if (response.action !== "run")
+        throw new Error("agent_task_claim_response_malformed");
+    const rawAssignment = requireClaimRecord(response.assignment, "agent_task_assignment_invalid");
+    let assignment;
+    if (rawAssignment.operation === "GAME") {
+        const { operation: _operation, ...gameAssignment } = rawAssignment;
+        const game = normalizeWorkerGameTaskAssignment(gameAssignment);
+        assignment = { operation: "GAME", ...game };
+    }
+    else if (rawAssignment.operation === "SCREENING") {
+        const task = requireClaimRecord(rawAssignment.task, "agent_task_assignment_invalid");
+        const request = requireClaimRecord(rawAssignment.request, "agent_task_assignment_invalid");
+        const execution = requireClaimRecord(rawAssignment.execution, "agent_task_assignment_invalid");
+        const taskId = parsePositiveInteger(task.id, "agent_task_assignment_task_id_missing");
+        const token = typeof task.token === "string" ? task.token.trim() : "";
+        const accessToken = typeof task.accessToken === "string" ? task.accessToken.trim() : "";
+        const taskType = typeof task.type === "string" ? task.type.trim().toUpperCase() : "";
+        const prompt = typeof request.prompt === "string" ? request.prompt : "";
+        if (!token ||
+            !accessToken ||
+            task.attempt !== 0 ||
+            !["NEW_GAME", "STATIC_GAME", "REMIX_GAME", "GAME_UPDATE"].includes(taskType) ||
+            !prompt.trim() ||
+            !Array.isArray(request.attachments) ||
+            !request.outputSchema ||
+            typeof request.outputSchema !== "object" ||
+            !Array.isArray(rawAssignment.inputs) ||
+            execution.provider !== "CODEX" ||
+            execution.model !== "gpt-5.6-luna" ||
+            execution.reasoningEffort !== "high" ||
+            execution.sandbox !== "read-only") {
+            throw new Error("agent_task_assignment_invalid");
+        }
+        assignment = rawAssignment;
+        assignment.task.id = taskId;
+    }
+    else if (rawAssignment.operation === "GENERATION") {
+        const task = requireClaimRecord(rawAssignment.task, "agent_task_assignment_invalid");
+        const request = requireClaimRecord(rawAssignment.request, "agent_task_assignment_invalid");
+        const execution = requireClaimRecord(rawAssignment.execution, "agent_task_assignment_invalid");
+        const taskId = parsePositiveInteger(task.id, "agent_task_assignment_task_id_missing");
+        const attempt = parsePositiveInteger(task.attempt, "agent_task_assignment_attempt_missing");
+        const token = typeof task.token === "string" ? task.token.trim() : "";
+        const accessToken = typeof task.accessToken === "string" ? task.accessToken.trim() : "";
+        const taskType = typeof task.type === "string" ? task.type.trim().toUpperCase() : "";
+        const requestKind = typeof request.kind === "string" ? request.kind.trim().toUpperCase() : "";
+        const provider = execution.provider;
+        const model = typeof execution.model === "string" ? execution.model.trim() : "";
+        if (!token ||
+            !accessToken ||
+            !["TEXT", "JSON", "IMAGE", "MODEL_3D", "VIDEO", "SFX", "SPEECH", "MUSIC"].includes(taskType) ||
+            requestKind !== taskType ||
+            (provider !== "CODEX" && provider !== "FAL") ||
+            !model ||
+            !Array.isArray(rawAssignment.inputs)) {
+            throw new Error("agent_task_assignment_invalid");
+        }
+        assignment = rawAssignment;
+        assignment.task.id = taskId;
+        assignment.task.attempt = attempt;
+    }
+    else {
+        throw new Error("agent_task_assignment_operation_invalid");
     }
     const lease = requireClaimRecord(response.lease, "agent_task_claim_missing_lease_token");
-    const token = typeof lease.token === "string" ? lease.token.trim() : "";
+    const leaseToken = typeof lease.token === "string" ? lease.token.trim() : "";
     const expiresAt = typeof lease.expiresAt === "string" ? lease.expiresAt.trim() : "";
-    if (!token || !expiresAt || Number.isNaN(Date.parse(expiresAt))) {
+    if (!leaseToken || !expiresAt || Number.isNaN(Date.parse(expiresAt))) {
         throw new Error("agent_task_claim_missing_lease_token");
     }
     return {
-        protocolVersion: 3,
+        protocolVersion: 5,
         action: "run",
         assignment,
-        lease: { token, expiresAt },
+        lease: { token: leaseToken, expiresAt },
         updatePolicy: updatePolicy,
     };
 }
@@ -837,6 +1009,10 @@ function resolveWorkerHomeDir() {
     }
     return node_path_1.default.join(node_os_1.default.homedir(), "PlayDropWorker");
 }
+async function configureWorkerFal() {
+    await (0, generation_1.configureFalCredential)(resolveWorkerHomeDir());
+    (0, output_1.printSuccess)("Fal is configured for this PlayDrop worker.");
+}
 function workerStateFilePath() {
     return node_path_1.default.join(resolveWorkerStateDir(), "current-task.json");
 }
@@ -853,13 +1029,24 @@ async function pruneWorkerTaskWorkspaces(incomingWorkspaceDir, retention = expor
         return [];
     }
     const incoming = node_path_1.default.resolve(incomingWorkspaceDir);
+    const retainedCutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
     const entries = (0, node_fs_1.readdirSync)(tasksRoot, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => node_path_1.default.join(tasksRoot, entry.name))
         .filter((dir) => dir !== incoming)
-        .map((dir) => ({ dir, mtimeMs: (0, node_fs_1.statSync)(dir).mtimeMs }))
+        .map((dir) => {
+        const marker = node_path_1.default.join(dir, ".playdrop", "game-source-retained.json");
+        const markerMtime = (0, node_fs_1.existsSync)(marker) ? (0, node_fs_1.statSync)(marker).mtimeMs : null;
+        return {
+            dir,
+            mtimeMs: (0, node_fs_1.statSync)(dir).mtimeMs,
+            retainedGameSource: markerMtime !== null && markerMtime >= retainedCutoff,
+        };
+    })
         .sort((a, b) => b.mtimeMs - a.mtimeMs);
-    const stale = entries.slice(Math.max(0, retention - 1));
+    const stale = entries
+        .filter((entry) => !entry.retainedGameSource)
+        .slice(Math.max(0, retention - 1));
     const removed = [];
     for (const entry of stale) {
         await (0, promises_1.rm)(entry.dir, { recursive: true, force: true });
@@ -889,11 +1076,15 @@ async function prepareClaimedTaskWorkspace(input) {
         (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 }),
+        (0, promises_1.rm)(node_path_1.default.join(input.workspaceDir, ".playdrop", "task-upload-failure.json"), { force: true }),
         ...retainedProjectBindings.map((file) => (0, promises_1.rm)(file, { force: true })),
     ]);
     return { resumed: true };
 }
 function buildWorkerTaskContext(input) {
+    if (input.target === "FIRST_PARTY" && !input.taskAccessToken?.trim()) {
+        throw new Error("agent_task_access_token_missing");
+    }
     const playdrop = input.metadata.playdrop;
     if (!playdrop || typeof playdrop !== "object" || Array.isArray(playdrop)) {
         throw new Error("agent_task_context_playdrop_metadata_missing");
@@ -937,6 +1128,7 @@ function buildWorkerTaskContext(input) {
         taskId: input.taskId,
         attempt: input.attempt,
         taskToken: input.taskToken,
+        taskAccessToken: input.taskAccessToken?.trim() || null,
         taskType: input.taskType,
         metadata: input.metadata,
         kind,
@@ -951,6 +1143,7 @@ function buildWorkerTaskContext(input) {
         remixSourceRef,
         allowedTemplateKeys,
         reviewAppVersionId,
+        gameSourceGit: input.gameSourceGit === true,
     };
 }
 function buildWorkerTaskContextV2(assignment) {
@@ -958,10 +1151,12 @@ function buildWorkerTaskContextV2(assignment) {
         taskId: assignment.task.id,
         attempt: assignment.task.attempt,
         taskToken: assignment.task.token,
+        taskAccessToken: assignment.task.accessToken ?? null,
         taskType: assignment.task.type,
         metadata: assignment.task.metadata,
         prompt: assignment.request.prompt,
         target: assignment.task.executionTarget,
+        gameSourceGit: Boolean("gameSource" in assignment && assignment.gameSource),
     });
 }
 function normalizeWorkerInstrumentSurface(value) {
@@ -1040,9 +1235,30 @@ function workerTaskContextPath(workspaceDir) {
 function workerTaskUploadResultPath(workspaceDir) {
     return node_path_1.default.join(workspaceDir, ".playdrop", "task-upload-result.json");
 }
+function workerTaskUploadFailurePath(workspaceDir) {
+    return node_path_1.default.join(workspaceDir, ".playdrop", "task-upload-failure.json");
+}
 function workerTaskMaterialsPath(workspaceDir) {
     return node_path_1.default.join(workspaceDir, ".playdrop", "task-materials.json");
 }
+function workerGameSourceReadinessPath(workspaceDir) {
+    return node_path_1.default.join(workspaceDir, ".playdrop", "game-source-ready.json");
+}
+function workerGameSourceCompletionPath(workspaceDir) {
+    return node_path_1.default.join(workspaceDir, ".playdrop", "game-source-completion.json");
+}
+function readWorkerGameSourceCompletion(workspaceDir) {
+    const file = workerGameSourceCompletionPath(workspaceDir);
+    if (!(0, node_fs_1.existsSync)(file))
+        return null;
+    const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf8"));
+    if (!Number.isSafeInteger(parsed.taskId) || Number(parsed.taskId) <= 0 ||
+        !Number.isSafeInteger(parsed.attempt) || Number(parsed.attempt) <= 0 ||
+        typeof parsed.summary !== "string" || !parsed.summary.trim()) {
+        throw new Error("game_source_completion_intent_invalid");
+    }
+    return parsed;
+}
 function serializeWorkerTaskContext(taskContext) {
     const playdrop = taskContext.metadata.playdrop;
     if (!playdrop || typeof playdrop !== "object" || Array.isArray(playdrop)) {
@@ -1072,6 +1288,7 @@ function serializeWorkerTaskContext(taskContext) {
             id: taskContext.taskId,
             attempt: taskContext.attempt,
             token: taskContext.taskToken,
+            ...(taskContext.taskAccessToken ? { accessToken: taskContext.taskAccessToken } : {}),
             type: taskContext.taskType,
             executionTarget: taskContext.target,
             metadata,
@@ -1082,6 +1299,7 @@ function serializeWorkerTaskContext(taskContext) {
         worker: {
             devPort: taskContext.devPort,
             env: taskContext.env,
+            gameSourceGit: taskContext.gameSourceGit,
         },
     };
 }
@@ -1098,7 +1316,7 @@ async function stageWorkerTaskContext(input) {
 async function writeWorkerTaskContextFile(workspaceDir, taskContext) {
     await (0, promises_1.writeFile)(workerTaskContextPath(workspaceDir), JSON.stringify(serializeWorkerTaskContext(taskContext), null, 2), "utf8");
 }
-function findWorkspaceTaskFile(startDir, basename) {
+function findOptionalWorkspaceTaskFile(startDir, basename) {
     let current = node_path_1.default.resolve(startDir);
     while (true) {
         const candidate = node_path_1.default.join(current, ".playdrop", basename);
@@ -1107,11 +1325,18 @@ function findWorkspaceTaskFile(startDir, basename) {
         }
         const parent = node_path_1.default.dirname(current);
         if (parent === current) {
-            throw new Error(`task_context_missing:${basename}`);
+            return null;
         }
         current = parent;
     }
 }
+function findWorkspaceTaskFile(startDir, basename) {
+    const file = findOptionalWorkspaceTaskFile(startDir, basename);
+    if (!file) {
+        throw new Error(`task_context_missing:${basename}`);
+    }
+    return file;
+}
 function readTaskContextFile(startDir = node_process_1.default.cwd()) {
     const file = findWorkspaceTaskFile(startDir, "task.json");
     const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf8"));
@@ -1121,6 +1346,7 @@ function readTaskContextFile(startDir = node_process_1.default.cwd()) {
     const taskId = Number(task?.id);
     const attempt = Number(task?.attempt);
     const taskToken = typeof task?.token === "string" ? task.token.trim() : "";
+    const taskAccessToken = typeof task?.accessToken === "string" ? task.accessToken.trim() : "";
     const taskType = typeof task?.type === "string" ? task.type.trim() : "";
     const metadata = task?.metadata && typeof task.metadata === "object" && !Array.isArray(task.metadata) ? task.metadata : null;
     const prompt = typeof request?.prompt === "string" ? request.prompt : "";
@@ -1132,6 +1358,7 @@ function readTaskContextFile(startDir = node_process_1.default.cwd()) {
         !Number.isInteger(attempt) ||
         attempt <= 0 ||
         !taskToken ||
+        (task?.executionTarget === "FIRST_PARTY" && !taskAccessToken) ||
         !taskType ||
         !metadata ||
         (task?.executionTarget !== "FIRST_PARTY" && task?.executionTarget !== "PERSONAL") ||
@@ -1148,10 +1375,12 @@ function readTaskContextFile(startDir = node_process_1.default.cwd()) {
                 taskId,
                 attempt,
                 taskToken,
+                taskAccessToken,
                 taskType,
                 metadata,
                 prompt,
                 target: task.executionTarget,
+                gameSourceGit: worker?.gameSourceGit === true,
             }),
             devPort,
             env,
@@ -1165,24 +1394,189 @@ function hasAgentTaskUploadedArtifact(task) {
     return ((Number.isInteger(task.appId) && Number(task.appId) > 0) ||
         (Number.isInteger(task.appVersionId) && Number(task.appVersionId) > 0));
 }
-async function appendWorkerTranscriptChunks(input) {
-    const batchSize = input.batchSize ?? WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE;
-    if (!Number.isInteger(batchSize) || batchSize <= 0 || batchSize > WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE) {
-        throw new Error(`invalid_worker_transcript_chunk_batch_size:${batchSize}`);
-    }
-    for (let index = 0; index < input.chunks.length; index += batchSize) {
-        await input.client.workerAppendAgentTaskTranscriptChunks(input.taskId, {
+function buildWorkerTranscriptUploadHeaders(input) {
+    return {
+        ...input.headers,
+        "content-type": input.contentType,
+        "content-md5": input.md5Base64,
+    };
+}
+async function archiveWorkerTranscriptBestEffort(input) {
+    if (!input.transcriptPath || !(0, node_fs_1.existsSync)(input.transcriptPath))
+        return;
+    try {
+        const content = (0, node_fs_1.readFileSync)(input.transcriptPath);
+        const contentSha256 = (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+        const contentMd5Base64 = (0, node_crypto_1.createHash)("md5").update(content).digest("base64");
+        const request = {
             workerKey: input.workerKey,
             leaseToken: input.leaseToken,
-            chunks: input.chunks.slice(index, index + batchSize),
-        });
+            attempt: input.attempt,
+            sha256: contentSha256,
+            md5Base64: contentMd5Base64,
+            bytes: content.length,
+        };
+        const prepared = await input.client.workerPrepareAgentTaskTranscript(input.taskId, request);
+        if (prepared.upload) {
+            const response = await fetch(prepared.upload.url, {
+                method: "PUT",
+                headers: buildWorkerTranscriptUploadHeaders({
+                    headers: prepared.upload.headers,
+                    contentType: prepared.upload.contentType,
+                    md5Base64: contentMd5Base64,
+                }),
+                body: Uint8Array.from(content),
+            });
+            if (!response.ok)
+                throw new Error(`agent_task_transcript_upload_failed:${response.status}`);
+        }
+        await input.client.workerCompleteAgentTaskTranscript(input.taskId, request);
+    }
+    catch (error) {
+        const archiveDir = node_path_1.default.join(resolveWorkerHomeDir(), "transcripts", "unarchived");
+        try {
+            (0, node_fs_1.mkdirSync)(archiveDir, { recursive: true });
+            const retainedPath = node_path_1.default.join(archiveDir, `task-${input.taskId}-attempt-${input.attempt}.ndjson`);
+            await (0, promises_1.copyFile)(input.transcriptPath, retainedPath);
+            const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+            for (const entry of (0, node_fs_1.readdirSync)(archiveDir)) {
+                const candidate = node_path_1.default.join(archiveDir, entry);
+                if ((0, node_fs_1.statSync)(candidate).isFile() && (0, node_fs_1.statSync)(candidate).mtimeMs < cutoff) {
+                    (0, node_fs_1.rmSync)(candidate, { force: true });
+                }
+            }
+        }
+        catch (retentionError) {
+            console.error(`Transcript spool retention failed: ${retentionError instanceof Error ? retentionError.message : String(retentionError)}`);
+        }
+        console.error(`Transcript archival did not complete; the local spool was retained for seven days: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 function resolveTaskWorkspaceDir(startDir = node_process_1.default.cwd()) {
     return node_path_1.default.dirname(node_path_1.default.dirname(findWorkspaceTaskFile(startDir, "task.json")));
 }
+function describeTaskUploadFailure(error) {
+    const fullRawError = (error instanceof Error ? error.message : String(error)).trim() || "task_upload_failed";
+    const errorText = fullRawError.slice(0, 40000);
+    const explicitCode = (/^([a-z0-9_.-]+):/.exec(errorText)?.[1] ||
+        (error instanceof types_1.ApiError && typeof error.code === "string" ? error.code.trim() : "") ||
+        "").slice(0, 160);
+    if (explicitCode === "agent_task_playtest_smoke_check_not_interactive") {
+        return {
+            kind: "failure",
+            category: "upload_validation",
+            code: explicitCode,
+            message: "We built the game, but PlayDrop could not verify that its recorded controls changed the game, so it was not uploaded. Retry to repair the controls or playtest recording.",
+            retryable: true,
+            source: "agent",
+        };
+    }
+    let terminalReason = {
+        ...(0, types_1.classifyAgentTaskTerminalReason)(errorText, "worker"),
+        ...(explicitCode ? { code: explicitCode } : {}),
+    };
+    if (error instanceof types_1.ApiError && error.status === 429) {
+        terminalReason = {
+            ...terminalReason,
+            category: "provider_capacity",
+            code: explicitCode || "task_upload_rate_limited",
+            retryable: true,
+        };
+    }
+    else if (error instanceof types_1.ApiError && error.status >= 500) {
+        terminalReason = {
+            ...terminalReason,
+            category: "agent_failure",
+            code: explicitCode || "task_upload_platform_error",
+            retryable: true,
+        };
+    }
+    let creatorMessage = null;
+    if (error instanceof types_1.ApiError && error.status >= 500) {
+        creatorMessage = "PlayDrop could not complete the game upload.";
+    }
+    else if (terminalReason.category === "provider_connection") {
+        creatorMessage = "PlayDrop could not be reached while uploading the game.";
+    }
+    else if (terminalReason.category === "provider_timeout") {
+        creatorMessage = "The game upload did not finish before the timeout.";
+    }
+    else if (terminalReason.category === "provider_capacity") {
+        creatorMessage = "PlayDrop could not accept the game upload yet.";
+    }
+    if (creatorMessage) {
+        return {
+            ...terminalReason,
+            message: creatorMessage,
+            source: "worker",
+        };
+    }
+    return terminalReason;
+}
+async function recordTaskUploadFailure(input) {
+    const failure = {
+        schemaVersion: 2,
+        taskId: input.taskContext.taskId,
+        attempt: input.taskContext.attempt,
+        terminalReason: describeTaskUploadFailure(input.error),
+        failedAt: new Date().toISOString(),
+    };
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(workerTaskUploadFailurePath(input.workspaceDir)), { recursive: true });
+    await (0, promises_1.writeFile)(workerTaskUploadFailurePath(input.workspaceDir), JSON.stringify(failure, null, 2), "utf8");
+    return failure;
+}
+function readTaskUploadFailureFile(startDir = node_process_1.default.cwd()) {
+    const file = findOptionalWorkspaceTaskFile(startDir, "task-upload-failure.json");
+    if (!file)
+        return null;
+    const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf8"));
+    const taskId = Number(parsed.taskId);
+    const attempt = Number(parsed.attempt);
+    const terminalReasonValue = parsed.terminalReason;
+    const code = typeof terminalReasonValue?.code === "string" ? terminalReasonValue.code.trim() : "";
+    const message = typeof terminalReasonValue?.message === "string" ? terminalReasonValue.message.trim() : "";
+    const failedAt = typeof parsed.failedAt === "string" ? parsed.failedAt.trim() : "";
+    if (parsed.schemaVersion !== 2 ||
+        !Number.isInteger(taskId) ||
+        taskId <= 0 ||
+        !Number.isInteger(attempt) ||
+        attempt <= 0 ||
+        terminalReasonValue?.kind !== "failure" ||
+        !TASK_UPLOAD_FAILURE_CATEGORIES.has(terminalReasonValue.category) ||
+        !code ||
+        code.length > 160 ||
+        !message ||
+        message.length > 600 ||
+        typeof terminalReasonValue.retryable !== "boolean" ||
+        !TASK_UPLOAD_FAILURE_SOURCES.has(terminalReasonValue.source) ||
+        !failedAt ||
+        !Number.isFinite(Date.parse(failedAt))) {
+        throw new Error(`task_upload_failure_invalid:${file}`);
+    }
+    return {
+        schemaVersion: 2,
+        taskId,
+        attempt,
+        terminalReason: {
+            kind: "failure",
+            category: terminalReasonValue.category,
+            code,
+            message,
+            retryable: terminalReasonValue.retryable,
+            source: terminalReasonValue.source,
+        },
+        failedAt,
+    };
+}
 function readTaskUploadResultFile(startDir = node_process_1.default.cwd()) {
-    const file = findWorkspaceTaskFile(startDir, "task-upload-result.json");
+    const file = findOptionalWorkspaceTaskFile(startDir, "task-upload-result.json");
+    if (!file) {
+        const failure = readTaskUploadFailureFile(startDir);
+        if (failure) {
+            throw new Error(`task_done_blocked_by_upload_failure:${failure.terminalReason.code}: ${failure.terminalReason.message}`);
+        }
+        throw new Error("task_context_missing:task-upload-result.json");
+    }
     const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf8"));
     const taskId = Number(parsed.taskId);
     const appId = Number(parsed.appId);
@@ -1380,34 +1774,7 @@ function resolveWorkspaceFileDestination(workspaceDir, relativePath) {
     }
     return destination;
 }
-async function stageAssignmentWorkspaceV2(workspaceDir, workspace) {
-    for (const file of workspace.files) {
-        const normalized = normalizeAssignmentContent({
-            path: file.path,
-            contentBase64: file.contentBase64,
-            sha256: file.sha256,
-            sizeBytes: file.sizeBytes,
-            code: "agent_task_assignment_workspace_file",
-        });
-        const destination = resolveWorkspaceFileDestination(workspaceDir, normalized.path);
-        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
-        await (0, promises_1.writeFile)(destination, normalized.buffer);
-    }
-    for (const archive of workspace.archives) {
-        const normalized = normalizeAssignmentContent({
-            path: archive.path,
-            contentBase64: archive.contentBase64,
-            sha256: archive.sha256,
-            sizeBytes: archive.sizeBytes,
-            code: "agent_task_assignment_workspace_archive",
-        });
-        const destination = resolveWorkspaceFileDestination(workspaceDir, normalized.path);
-        await (0, promises_1.mkdir)(destination, { recursive: true });
-        (0, archive_staging_1.extractZipArchive)(new Uint8Array(normalized.buffer), destination);
-        await removeStaleWorkerControlFiles(destination);
-    }
-}
-async function stageAssignmentWorkspaceV3(workspaceDir, workspace, options = {}) {
+async function stageAssignmentWorkspace(workspaceDir, workspace, options = {}) {
     for (const file of workspace.files) {
         const normalized = normalizeAssignmentContent({
             path: file.path,
@@ -1425,6 +1792,7 @@ async function stageAssignmentWorkspaceV3(workspaceDir, workspace, options = {})
         await (0, archive_staging_1.stageWorkspaceArchiveInChild)({
             downloadUrl: normalizeWorkspaceArchiveDownloadUrl(archive.downloadUrl),
             expectedSize: Number(archive.sizeBytes),
+            expectedSha256: archive.sha256,
             targetDir: destination,
             timeoutMs: options.timeoutMs ?? exports.WORKSPACE_ARCHIVE_DOWNLOAD_TIMEOUT_MS,
         });
@@ -1975,13 +2343,15 @@ function buildWorkerCapabilities(input) {
         : null;
     const maxParallelTasks = input.maxParallelTasks ?? DEFAULT_WORKER_MAX_PARALLEL_TASKS;
     const runningTaskCount = input.runningTaskCount ?? 0;
+    const requireGenerationRuntime = input.requireGenerationRuntime === true;
     const degradedReasons = [];
+    const gameSourceInventory = (0, game_source_git_1.readGameSourceWorkerInventory)(resolveWorkerHomeDir());
     const agents = [];
     if (codexVersion) {
-        if (!codexAuthenticated) {
+        if (requireGenerationRuntime && !codexAuthenticated) {
             degradedReasons.push("codex_not_authenticated");
         }
-        if (codexModels.length === 0) {
+        if (requireGenerationRuntime && codexModels.length === 0) {
             degradedReasons.push("codex_models_unavailable");
         }
         agents.push({
@@ -1994,12 +2364,6 @@ function buildWorkerCapabilities(input) {
         });
     }
     if (claudeVersion) {
-        if (!claudeAuthenticated) {
-            degradedReasons.push("claude_not_authenticated");
-        }
-        if (claudeModels.length === 0) {
-            degradedReasons.push("claude_models_unavailable");
-        }
         agents.push({
             agent: "CLAUDE_CODE",
             cliVersion: claudeVersion,
@@ -2010,12 +2374,6 @@ function buildWorkerCapabilities(input) {
         });
     }
     if (grokVersion) {
-        if (!grokAuthenticated) {
-            degradedReasons.push("grok_not_authenticated");
-        }
-        if (grokModels.length === 0) {
-            degradedReasons.push("grok_models_unavailable");
-        }
         agents.push({
             agent: "GROK_BUILD",
             cliVersion: grokVersion,
@@ -2026,10 +2384,6 @@ function buildWorkerCapabilities(input) {
         });
     }
     if (cursorVersion) {
-        degradedReasons.push("cursor_runner_not_configured");
-        if (!cursorAuthenticated) {
-            degradedReasons.push("cursor_not_authenticated");
-        }
         agents.push({
             agent: "CURSOR_COMPOSER",
             cliVersion: cursorVersion,
@@ -2041,17 +2395,120 @@ function buildWorkerCapabilities(input) {
     if (agents.length === 0) {
         throw new Error("agent_cli_not_found: install and authenticate Codex, Claude Code, Grok Build, or Cursor before starting a PlayDrop worker.");
     }
+    const codexReady = agents.some((agent) => agent.agent === "CODEX" && agent.ready === true);
+    const codexImageGenerationAvailable = input.codexImageGenerationAvailable === true;
+    const falConfigured = input.falConfigured ?? (0, generation_1.hasFalCredential)(resolveWorkerHomeDir());
+    const falAuthenticated = input.falAuthenticated ?? falConfigured;
+    const ffmpegReady = input.ffmpegReady ?? (workerCommandExists("ffmpeg") && workerCommandExists("ffprobe"));
+    const generationProviders = [];
+    if (codexReady) {
+        generationProviders.push({
+            provider: "CODEX",
+            kind: "TEXT",
+            model: "gpt-5.6-luna",
+            sourceModes: ["TEXT"],
+            authenticated: true,
+            ready: true,
+            features: ["SANDBOXED_EXEC"],
+        }, {
+            provider: "CODEX",
+            kind: "JSON",
+            model: "gpt-5.6-luna",
+            sourceModes: ["TEXT"],
+            authenticated: true,
+            ready: true,
+            features: ["SANDBOXED_EXEC", "JSON_SCHEMA"],
+        });
+    }
+    if (codexReady && codexImageGenerationAvailable) {
+        generationProviders.push({
+            provider: "CODEX",
+            kind: "IMAGE",
+            model: "gpt-5.6-luna",
+            sourceModes: ["TEXT", "IMAGE", "MULTI_IMAGE"],
+            authenticated: true,
+            ready: true,
+            features: ["SANDBOXED_EXEC", "IMAGE_GENERATION"],
+        });
+    }
+    if (requireGenerationRuntime && !codexVersion)
+        degradedReasons.push("codex_not_installed");
+    if (requireGenerationRuntime && codexReady && !codexImageGenerationAvailable) {
+        degradedReasons.push("codex_image_generation_unavailable");
+    }
+    if (falConfigured && falAuthenticated && codexReady && ffmpegReady) {
+        generationProviders.push({
+            provider: "FAL",
+            kind: "SPEECH",
+            model: "fal-ai/elevenlabs/tts/turbo-v2.5",
+            sourceModes: ["TEXT"],
+            authenticated: true,
+            ready: true,
+            features: ["CODEX_METADATA", "FFMPEG", "WAVEFORM"],
+        }, ...[
+            ["fal-ai/veo3.1/fast", "TEXT"],
+            ["fal-ai/veo3.1/fast/image-to-video", "IMAGE"],
+            ["fal-ai/veo3.1/fast/first-last-frame-to-video", "FIRST_LAST_FRAME"],
+        ].map(([model, sourceMode]) => ({
+            provider: "FAL",
+            kind: "VIDEO",
+            model,
+            sourceModes: [sourceMode],
+            authenticated: true,
+            ready: true,
+            features: ["CODEX_METADATA", "FFMPEG", "THUMBNAIL"],
+        })), ...[
+            ["fal-ai/meshy/v6/text-to-3d", "TEXT"],
+            ["fal-ai/meshy/v6/image-to-3d", "IMAGE"],
+            ["fal-ai/meshy/v6/multi-image-to-3d", "MULTI_IMAGE"],
+        ].map(([model, sourceMode]) => ({
+            provider: "FAL",
+            kind: "MODEL_3D",
+            model,
+            sourceModes: [sourceMode],
+            authenticated: true,
+            ready: true,
+            features: ["CODEX_METADATA", "GLB_VALIDATION", "THUMBNAIL"],
+        })));
+        if (codexImageGenerationAvailable) {
+            generationProviders.push({
+                provider: "FAL",
+                kind: "MUSIC",
+                model: "fal-ai/elevenlabs/music",
+                sourceModes: ["TEXT"],
+                authenticated: true,
+                ready: true,
+                features: ["CODEX_METADATA", "CODEX_IMAGE", "FFMPEG"],
+            }, {
+                provider: "FAL",
+                kind: "SFX",
+                model: "fal-ai/elevenlabs/sound-effects/v2",
+                sourceModes: ["TEXT"],
+                authenticated: true,
+                ready: true,
+                features: ["CODEX_METADATA", "CODEX_IMAGE", "FFMPEG"],
+            });
+        }
+    }
+    const supportedGenerationKinds = new Set(generationProviders.map((provider) => provider.kind));
+    const supportedKinds = WORKER_SUPPORTED_KINDS.filter((kind) => !["TEXT", "JSON", "IMAGE", "MODEL_3D", "VIDEO", "SFX", "SPEECH", "MUSIC"].includes(kind) || supportedGenerationKinds.has(kind));
+    const hasReadyAgent = agents.some((agent) => agent.ready === true);
+    if (!hasReadyAgent && degradedReasons.length === 0)
+        degradedReasons.push("agent_cli_not_authenticated");
     return {
         agent: agents[0].agent,
-        supportedKinds: [...WORKER_SUPPORTED_KINDS],
+        supportedKinds,
         maxParallelTasks,
         runningTaskCount,
         cliVersion: (0, clientInfo_1.getCliVersion)(),
         nodeVersion: node_process_1.default.versions.node,
         agents,
-        ready: agents.some((agent) => agent.ready === true),
+        generationProviders,
+        ready: hasReadyAgent && degradedReasons.length === 0,
         degradedReasons,
         wrapperContractVersion: (0, runtime_1.readPositiveEnvInt)("PLAYDROP_WORKER_WRAPPER_CONTRACT_VERSION", WORKER_WRAPPER_CONTRACT_VERSION),
+        gameSourceGit: 1,
+        gameSource: gameSourceInventory,
         ...(npmVersion ? { npmVersion } : {}),
         ...(playwright ? { playwright } : {}),
         os: node_process_1.default.platform,
@@ -2060,7 +2517,7 @@ function buildWorkerCapabilities(input) {
 }
 function buildWorkerClaimBody(input) {
     return {
-        protocolVersion: 3,
+        protocolVersion: 5,
         workerKey: input.workerKey,
         capabilities: {
             ...input.capabilities,
@@ -2317,6 +2774,7 @@ async function prepareCodexRunHomes(input) {
             workerUsername: input.workerUsername,
             envName: input.envName,
             playdropConfig: input.playdropConfig,
+            accessToken: input.playdropAccessToken,
         });
     }
     return { homeDir, codexHomeDir };
@@ -2326,7 +2784,8 @@ async function stageWorkerPlaydropSession(input) {
     const envName = input.envName.trim();
     const config = input.playdropConfig ?? (0, config_1.loadConfig)();
     const session = config.accounts?.[workerUsername]?.[envName];
-    if (!workerUsername || !envName || !session?.token?.trim()) {
+    const accessToken = input.accessToken?.trim() || session?.token?.trim() || "";
+    if (!workerUsername || !envName || !accessToken) {
         throw new Error(`worker_playdrop_session_missing:${workerUsername || "unknown"}:${envName || "unknown"}`);
     }
     const playdropConfigDir = node_path_1.default.join(input.homeDir, ".playdrop");
@@ -2334,13 +2793,13 @@ async function stageWorkerPlaydropSession(input) {
     await (0, promises_1.mkdir)(playdropConfigDir, { recursive: true, mode: 0o700 });
     await (0, promises_1.chmod)(playdropConfigDir, 0o700);
     await (0, promises_1.writeFile)(playdropConfigPath, JSON.stringify({
-        version: 2,
+        version: 3,
         currentAccount: { username: workerUsername, env: envName },
         accounts: {
             [workerUsername]: {
                 [envName]: {
-                    token: session.token.trim(),
-                    updatedAt: session.updatedAt,
+                    token: accessToken,
+                    updatedAt: session?.updatedAt ?? new Date().toISOString(),
                 },
             },
         },
@@ -2370,6 +2829,7 @@ async function prepareClaudeRunConfig(input) {
             workerUsername: input.workerUsername,
             envName: input.envName,
             playdropConfig: input.playdropConfig,
+            accessToken: input.playdropAccessToken,
         }),
     };
 }
@@ -2393,6 +2853,7 @@ async function prepareGrokRunConfig(input) {
             workerUsername: input.workerUsername,
             envName: input.envName,
             playdropConfig: input.playdropConfig,
+            accessToken: input.playdropAccessToken,
         });
     return {
         homeDir,
@@ -2428,6 +2889,7 @@ async function runCodex(input) {
         workspaceDir: input.stateDir ?? input.workspaceDir,
         workerUsername: input.workerUsername,
         envName: input.envName,
+        playdropAccessToken: input.taskAccessToken,
         stagePlaydropSession: !input.cleanRoom,
         preserveExisting: Boolean(input.resumeSessionId),
     });
@@ -2468,8 +2930,6 @@ async function runCodex(input) {
             workspaceDir: input.workspaceDir,
             model: input.codexModel.model,
             reasoningEffort: input.codexModel.reasoningEffort,
-            networkAccess: input.cleanRoom || (0, runtime_1.readEnvBoolean)("PLAYDROP_WORKER_AGENT_NETWORK_ACCESS", false),
-            sandboxMode: (0, runtime_1.readCodexSandboxMode)(),
             imagePaths: input.imagePaths,
             resumeSessionId: input.resumeSessionId,
         }),
@@ -2492,6 +2952,7 @@ async function runCodex(input) {
                 homeDir,
                 codexHomeDir,
                 playwrightBrowsersPath: resolveWorkerPlaywrightBrowsersPath(),
+                gameServerDev: input.gameServerDev ?? undefined,
             }),
         stdin: input.prompt,
         timeoutMs: input.timeoutMs ?? (0, runtime_1.readPositiveEnvInt)("PLAYDROP_WORKER_CODEX_TIMEOUT_MS", runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
@@ -2538,6 +2999,142 @@ async function runCodex(input) {
         tokensUsed: rolloutUsage.totalTokens,
     };
 }
+async function runPlaydropE2EGameFixture(input) {
+    if (!(0, e2e_fixtures_1.isPlaydropE2EGameKind)(input.taskContext.kind)) {
+        throw new Error(`playdrop_e2e_game_kind_invalid:${input.taskContext.kind}`);
+    }
+    const runRoot = node_path_1.default.join(input.workspaceDir, ".playdrop", "e2e-run");
+    const homeDir = node_path_1.default.join(runRoot, "home");
+    await (0, promises_1.rm)(runRoot, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(homeDir, { recursive: true, mode: 0o700 });
+    await (0, promises_1.chmod)(homeDir, 0o700);
+    const playdropConfigPath = await stageWorkerPlaydropSession({
+        homeDir,
+        workerUsername: input.workerUsername,
+        envName: input.envName,
+        accessToken: input.taskContext.taskAccessToken,
+    });
+    const childEnv = (0, runtime_1.buildWorkerChildEnv)({
+        binDir: input.binDir,
+        workerHomeDir: resolveWorkerHomeDir(),
+        taskId: input.taskContext.taskId,
+        taskToken: input.taskContext.taskToken,
+        attempt: input.taskContext.attempt,
+        envName: input.envName,
+        eventDir: input.eventDir,
+        devPort: input.devPort,
+        homeDir,
+        playdropConfigPath,
+        gameServerDev: input.gameServerDev ?? undefined,
+    });
+    const results = [];
+    const run = async (args) => {
+        const result = await (0, runtime_1.runLoggedProcess)({
+            command: "playdrop",
+            args,
+            cwd: input.projectDir,
+            env: childEnv,
+            timeoutMs: 10 * 60 * 1000,
+            maxOutputChars: runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS,
+            transcriptFlushIntervalMs: runtime_1.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS,
+            onTranscriptChunks: input.onTranscriptChunks,
+            onChild: input.onChild,
+        });
+        results.push(result);
+        return !result.timedOut && result.exitCode === 0 && result.signal === null;
+    };
+    try {
+        const claimsSlug = input.taskContext.kind === "NEW_GAME" || input.taskContext.kind === "REMIX_GAME";
+        const appName = claimsSlug
+            ? `playdrop-e2e-${input.taskContext.taskId}`
+            : input.taskContext.outputAppName?.trim() ?? "";
+        if (!appName)
+            throw new Error("playdrop_e2e_game_output_app_name_missing");
+        const updateSource = input.taskContext.kind === "GAME_UPDATE"
+            ? (0, taskSelection_1.selectTasks)(input.projectDir).tasks.find((task) => task.kind === "app" && task.name === appName)
+            : null;
+        if (input.taskContext.kind === "GAME_UPDATE" && !updateSource) {
+            throw new Error(`playdrop_e2e_update_source_app_missing:${appName}`);
+        }
+        const displayName = claimsSlug
+            ? `PlayDrop E2E ${input.taskContext.taskId}`
+            : input.taskContext.outputDisplayName?.trim() ||
+                updateSource?.displayName?.trim() ||
+                `PlayDrop E2E ${input.taskContext.taskId}`;
+        const subtitle = claimsSlug
+            ? "Deterministic worker fixture"
+            : input.taskContext.outputSubtitle?.trim() || updateSource?.subtitle?.trim() || "Deterministic worker fixture";
+        const primarySurface = claimsSlug
+            ? "DESKTOP"
+            : input.taskContext.outputPrimarySurface ?? updateSource?.primarySurface ?? "DESKTOP";
+        if (input.taskContext.kind === "REMIX_GAME" && !input.taskContext.remixSourceRef?.trim()) {
+            throw new Error("playdrop_e2e_remix_source_missing");
+        }
+        if (claimsSlug &&
+            !(await run([
+                "task",
+                "claim-slug",
+                "--app-name",
+                appName,
+                "--display-name",
+                displayName,
+                "--subtitle",
+                subtitle,
+                "--primary-surface",
+                primarySurface,
+            ]))) {
+            return mergePlaydropE2EProcessResults(results);
+        }
+        await (0, e2e_fixtures_1.replaceWithPlaydropE2EGameFixture)({
+            projectDir: input.projectDir,
+            taskId: input.taskContext.taskId,
+            kind: input.taskContext.kind,
+            appName,
+            displayName,
+            subtitle,
+            primarySurface,
+            outputVersion: input.taskContext.outputVersion,
+            remixSourceRef: input.taskContext.remixSourceRef?.trim() || null,
+        });
+        if (!(await run(["task", "upload"])))
+            return mergePlaydropE2EProcessResults(results);
+        await run([
+            "task",
+            "done",
+            "--summary",
+            `Completed the deterministic ${input.taskContext.kind} PlayDrop E2E fixture.`,
+        ]);
+        return mergePlaydropE2EProcessResults(results);
+    }
+    finally {
+        await (0, promises_1.rm)(runRoot, { recursive: true, force: true });
+    }
+}
+function mergePlaydropE2EProcessResults(results) {
+    const stdout = results.map((result) => result.stdout).filter(Boolean).join("\n");
+    const stderr = results.map((result) => result.stderr).filter(Boolean).join("\n");
+    const outputTail = results.map((result) => result.outputTail).filter(Boolean).join("\n").slice(-runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS);
+    const failed = results.find((result) => result.timedOut || result.exitCode !== 0 || result.signal !== null);
+    return {
+        exitCode: failed?.exitCode ?? results.at(-1)?.exitCode ?? 0,
+        signal: failed?.signal ?? null,
+        stdout,
+        stderr,
+        outputTail,
+        timedOut: failed?.timedOut ?? false,
+        tokenUsage: {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationInputTokens: 0,
+            cacheReadInputTokens: 0,
+            totalTokens: 0,
+            rawProviderUsage: { fixture: "playdrop-e2e-v1" },
+            usageParseError: null,
+        },
+        tokensUsed: 0,
+        providerSessionId: null,
+    };
+}
 async function runClaude(input) {
     const playdropConfigPath = input.cleanRoom
         ? null
@@ -2545,6 +3142,7 @@ async function runClaude(input) {
             workspaceDir: input.stateDir ?? input.workspaceDir,
             workerUsername: input.workerUsername,
             envName: input.envName,
+            playdropAccessToken: input.taskAccessToken,
         })).playdropConfigPath;
     const denyReadRoots = resolveClaudeDenyReadRoots(input.workspaceDir);
     const screenshotCollector = input.enableChrome || input.enablePlaywrightMcp
@@ -2566,6 +3164,7 @@ async function runClaude(input) {
             denyReadRoots,
             pluginDir: input.taskPluginRoot,
             playdropCliEnabled: !input.cleanRoom,
+            allowGit: input.allowGit,
             chrome: input.enableChrome,
             playwrightMcp: input.enablePlaywrightMcp,
             playwrightMcpConfigPath,
@@ -2587,6 +3186,7 @@ async function runClaude(input) {
                 devPort: input.devPort,
                 playdropConfigPath: playdropConfigPath,
                 playwrightBrowsersPath: resolveWorkerPlaywrightBrowsersPath(),
+                gameServerDev: input.gameServerDev ?? undefined,
             }),
         stdin: `${JSON.stringify({
             type: "user",
@@ -2669,6 +3269,7 @@ async function runGrok(input) {
         workspaceDir: input.stateDir ?? input.workspaceDir,
         workerUsername: input.workerUsername,
         envName: input.envName,
+        playdropAccessToken: input.taskAccessToken,
         preserveExisting: Boolean(input.resumeSessionId),
         stagePlaydropSession: !input.cleanRoom,
     });
@@ -2715,6 +3316,7 @@ async function runGrok(input) {
             homeDir,
             playdropConfigPath: playdropConfigPath,
             playwrightBrowsersPath: resolveWorkerPlaywrightBrowsersPath(),
+            gameServerDev: input.gameServerDev ?? undefined,
         });
     childEnv.HOME = homeDir;
     childEnv.GROK_HOME = grokHomeDir;
@@ -2779,9 +3381,9 @@ function resolveClaudeDenyReadRoots(workspaceDir) {
     }
     return roots;
 }
-// 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) {
+// Raw stdout/stderr tails stay out of task results on purpose. The local spool
+// is archived directly to private storage after the agent exits.
+function mergeAgentContinuationResults(runtime, initial, recovery, timeoutMarkerCode) {
     const sumNullable = (left, right) => left === null && right === null ? null : (left ?? 0) + (right ?? 0);
     const tokenUsage = runtime === "CODEX" && recovery.tokenUsage.totalTokens !== null
         ? recovery.tokenUsage
@@ -2799,7 +3401,7 @@ function mergeCreatorRecoveryResults(runtime, initial, recovery) {
                 ? "creator_recovery_usage_incomplete"
                 : null,
         };
-    const recoveryMarker = recovery.timedOut ? "\nagent_task_creation_recovery_timeout" : "";
+    const recoveryMarker = recovery.timedOut ? `\n${timeoutMarkerCode}` : "";
     return {
         ...recovery,
         stdout: `${initial.stdout}\n${recovery.stdout}`.slice(-runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS),
@@ -2811,6 +3413,12 @@ function mergeCreatorRecoveryResults(runtime, initial, recovery) {
         providerResolvedModel: recovery.providerResolvedModel ?? initial.providerResolvedModel ?? null,
     };
 }
+function mergeCreatorRecoveryResults(runtime, initial, recovery) {
+    return mergeAgentContinuationResults(runtime, initial, recovery, "agent_task_creation_recovery_timeout");
+}
+function mergeMissingAgentOutcomeRecoveryResults(runtime, initial, recovery) {
+    return mergeAgentContinuationResults(runtime, initial, recovery, "agent_task_outcome_recovery_timeout");
+}
 function buildAgentRunResult(result) {
     return {
         exitCode: result.exitCode,
@@ -2915,7 +3523,7 @@ async function recordAgentRunTelemetry(input) {
         completedAt: input.completedAt.toISOString(),
         ...(input.status === "FAILED"
             ? {
-                terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(agentFailureRawError(input.result), "agent"),
+                terminalReason: input.terminalReason ?? (0, types_1.classifyAgentTaskTerminalReason)(agentFailureRawError(input.result), "agent"),
             }
             : {}),
     });
@@ -2970,9 +3578,7 @@ function buildAgentFailureCode(agent, result, request) {
         return `agent_provider_overloaded:${provider}`;
     }
     if (providerStatus === 429 ||
-        providerStatus === 502 ||
-        providerStatus === 503 ||
-        providerStatus === 504 ||
+        (providerStatus !== null && providerStatus >= 500 && providerStatus <= 599) ||
         (agent === "CLAUDE_CODE" &&
             /\bResponse stalled mid-stream\.?(?:\s+The response above may be incomplete\.?)?/i.test(combinedOutput)) ||
         /\b(?:service|provider|api)\s+(?:is\s+)?(?:temporarily\s+)?unavailable\b/i.test(combinedOutput) ||
@@ -2982,6 +3588,9 @@ function buildAgentFailureCode(agent, result, request) {
     if (result.timedOut) {
         return `agent_provider_timeout:${provider}`;
     }
+    if (/\b(?:econnreset|econnrefused|network error|socket hang up|connection reset|connection lost|fetch failed)\b/i.test(combinedOutput)) {
+        return `agent_provider_connection:${provider}`;
+    }
     if (result.exitCode !== null) {
         return `agent_unknown_exit:${provider}:${result.exitCode}`;
     }
@@ -2990,7 +3599,7 @@ function buildAgentFailureCode(agent, result, request) {
     }
     return `agent_unknown_exit:${provider}`;
 }
-function classifyAgentAvailabilityFailureReason(errorCode) {
+function classifyAgentAvailabilityFailureReason(errorCode, retryTransientProviderFailure = false) {
     if (errorCode.startsWith("agent_provider_not_authenticated:")) {
         return "agent_not_authenticated";
     }
@@ -3001,6 +3610,10 @@ function classifyAgentAvailabilityFailureReason(errorCode) {
         errorCode.startsWith("agent_provider_temporarily_unavailable:")) {
         return "agent_temporarily_unavailable";
     }
+    if (retryTransientProviderFailure &&
+        (errorCode.startsWith("agent_provider_connection:") || errorCode.startsWith("agent_provider_timeout:"))) {
+        return "agent_temporarily_unavailable";
+    }
     if (errorCode.startsWith("requested_model_unavailable:")) {
         return "agent_model_unsupported";
     }
@@ -3031,6 +3644,9 @@ 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_provider_connection") {
+        return `${providerLabel} lost its connection 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.`;
     }
@@ -3076,6 +3692,7 @@ async function createLocalPlaydropShim(input) {
             `set "PLAYDROP_WORKER_TASK_ATTEMPT=${input.attempt}"`,
             `set "PLAYDROP_WORKER_TASK_DEV_PORT=${input.devPort}"`,
             `set "PLAYDROP_DEV_ROUTER_PORT=${input.devPort}"`,
+            ...(input.gameSourceGit ? ['set "PLAYDROP_GAME_SOURCE_GIT_ROOT=1"'] : []),
             `"${node_process_1.default.execPath}" "${cliEntrypoint}" %*`,
             "exit /b %ERRORLEVEL%",
             "",
@@ -3087,12 +3704,25 @@ async function createLocalPlaydropShim(input) {
             `export PLAYDROP_WORKER_TASK_ATTEMPT=${JSON.stringify(String(input.attempt))}`,
             `export PLAYDROP_WORKER_TASK_DEV_PORT=${JSON.stringify(String(input.devPort))}`,
             `export PLAYDROP_DEV_ROUTER_PORT=${JSON.stringify(String(input.devPort))}`,
+            ...(input.gameSourceGit ? ["export PLAYDROP_GAME_SOURCE_GIT_ROOT=1"] : []),
             `exec ${JSON.stringify(node_process_1.default.execPath)} ${JSON.stringify(cliEntrypoint)} "$@"`,
             "",
         ];
     await (0, promises_1.writeFile)(shimPath, shim.join(isWindows ? "\r\n" : "\n"), "utf8");
     if (!isWindows) {
         await (0, promises_1.chmod)(shimPath, 0o755);
+        const npxShimPath = node_path_1.default.join(binDir, "npx");
+        const npxShim = [
+            "#!/bin/sh",
+            'if [ "$1" = "playdrop" ]; then',
+            "  shift",
+            `  exec ${JSON.stringify(shimPath)} "$@"`,
+            "fi",
+            'PATH="${PATH#*:}" exec npx "$@"',
+            "",
+        ];
+        await (0, promises_1.writeFile)(npxShimPath, npxShim.join("\n"), "utf8");
+        await (0, promises_1.chmod)(npxShimPath, 0o755);
     }
     return binDir;
 }
@@ -3189,6 +3819,19 @@ function probeCodexModels() {
     }
     return parseCodexModelCatalog(result.output);
 }
+function codexFeatureEnabled(output, feature) {
+    const normalizedFeature = feature.trim();
+    if (!normalizedFeature)
+        return false;
+    return output.split(/\r?\n/).some((line) => {
+        const columns = line.trim().split(/\s+/);
+        return columns[0] === normalizedFeature && columns[columns.length - 1] === "true";
+    });
+}
+function probeCodexImageGeneration() {
+    const result = (0, shellProbe_1.runShell)("codex features list");
+    return result.exitCode === 0 && codexFeatureEnabled(result.output, "image_generation");
+}
 function probeClaudeInstallation() {
     const probe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)("claude"));
     if (probe.exitCode !== 0 || !probe.output.trim()) {
@@ -3320,12 +3963,21 @@ function probeReadyWorkerCapabilities(input) {
     const grokVersion = probeWorkerProviderIndependently(() => probeGrokInstallation()?.grokVersion ?? null, null);
     const cursorVersion = probeWorkerProviderIndependently(() => probeCursorInstallation()?.cursorVersion ?? null, null);
     const codexModels = codexVersion ? probeWorkerProviderIndependently(probeCodexModels, []) : [];
+    const codexImageGenerationAvailable = codexVersion
+        ? probeWorkerProviderIndependently(probeCodexImageGeneration, false)
+        : false;
     const claudeModels = claudeVersion ? probeWorkerProviderIndependently(probeClaudeModels, []) : [];
     const grokModels = grokVersion ? probeWorkerProviderIndependently(probeGrokModels, []) : [];
+    const workerHomeDir = resolveWorkerHomeDir();
+    const falConfigured = (0, generation_1.hasFalCredential)(workerHomeDir);
+    const falProbe = probeFalAuthentication(workerHomeDir);
     const capabilities = buildWorkerCapabilities({
         codexVersion,
         codexAuthenticated: codexVersion ? readCodexAuthenticated() : false,
         codexModels,
+        codexImageGenerationAvailable,
+        falConfigured,
+        falAuthenticated: falProbe.authenticated,
         claudeVersion,
         claudeAuthenticated: claudeVersion ? readClaudeAuthenticated() : false,
         claudeModels,
@@ -3338,8 +3990,9 @@ function probeReadyWorkerCapabilities(input) {
         playwright: input.playwright,
         maxParallelTasks: input.maxParallelTasks,
         runningTaskCount: 0,
+        requireGenerationRuntime: input.requireGenerationRuntime,
     });
-    if (!capabilities.ready) {
+    if (!capabilities.ready || (capabilities.degradedReasons?.length ?? 0) > 0) {
         const reasons = Array.isArray(capabilities.degradedReasons) && capabilities.degradedReasons.length > 0
             ? capabilities.degradedReasons.join(", ")
             : "no ready agent";
@@ -3446,11 +4099,18 @@ function describeWorkerPreflightReason(reason) {
         worker_preflight_recorder_hash_mismatch: "The PlayDrop macOS recorder does not match this CLI release.",
         worker_preflight_screen_recording_permission_missing: "Screen Recording permission is not granted to the PlayDrop recorder.",
         codex_not_authenticated: "Codex is installed but not authenticated.",
+        codex_not_installed: "Codex is required for generation work but is not installed.",
         codex_models_unavailable: "Codex is authenticated but reported no usable models.",
+        codex_image_generation_unavailable: "Codex built-in image generation is unavailable.",
         claude_not_authenticated: "Claude Code is installed but not authenticated.",
         claude_models_unavailable: "Claude Code is authenticated but reported no usable models.",
         grok_not_authenticated: "Grok Build is installed but not authenticated with a subscription login.",
         grok_models_unavailable: "Grok Build is authenticated but reported no usable models.",
+        fal_not_configured: "The Fal credential file is missing.",
+        fal_not_authenticated: "The Fal credential was rejected by the Fal queue API.",
+        fal_api_unreachable: "The Fal queue API could not be reached during worker readiness checks.",
+        ffmpeg_not_ready_for_generation: "ffmpeg or ffprobe is missing from PATH.",
+        agent_cli_not_authenticated: "No installed agent CLI has a usable authenticated model.",
         agent_cli_not_found: "No supported authenticated agent CLI is installed.",
     };
     return descriptions[reason] ?? reason;
@@ -3477,10 +4137,56 @@ function readWorkerTargetUpdateFailure() {
         minimumCliVersion: typeof parsed.minimumCliVersion === "string" ? parsed.minimumCliVersion : null,
     };
 }
-function collectWorkerLocalStatus() {
+function falAuthenticationProbeExitCode(status) {
+    if (status === 404)
+        return 0;
+    if (status === 401 || status === 403)
+        return 2;
+    return 3;
+}
+function probeFalAuthentication(workerHomeDir = resolveWorkerHomeDir(), deps = { spawnSync: node_child_process_1.spawnSync }) {
+    const credentialFile = (0, generation_1.falCredentialPath)(workerHomeDir);
+    if (!(0, node_fs_1.existsSync)(credentialFile)) {
+        return { authenticated: false, error: "fal_not_configured" };
+    }
+    const credential = (0, node_fs_1.readFileSync)(credentialFile, "utf8").trim();
+    if (!credential) {
+        return { authenticated: false, error: "fal_not_authenticated" };
+    }
+    const probe = deps.spawnSync(node_process_1.default.execPath, [
+        "-e",
+        [
+            "const chunks=[];",
+            "process.stdin.on('data',(chunk)=>chunks.push(chunk));",
+            "process.stdin.on('end',async()=>{",
+            "const key=Buffer.concat(chunks).toString('utf8').trim();",
+            "const controller=new AbortController();",
+            "const timeout=setTimeout(()=>controller.abort(),10000);",
+            "try{",
+            "const response=await fetch('https://queue.fal.run/fal-ai/elevenlabs/requests/playdrop-auth-probe/status?logs=0',{headers:{Authorization:`Key ${key}`},signal:controller.signal});",
+            "process.exitCode=response.status===404?0:response.status===401||response.status===403?2:3;",
+            "}catch{process.exitCode=3;}finally{clearTimeout(timeout);}",
+            "});",
+        ].join(""),
+    ], {
+        input: `${credential}\n`,
+        stdio: ["pipe", "ignore", "ignore"],
+        timeout: 15000,
+    });
+    if (probe.status === 0) {
+        return { authenticated: true, error: null };
+    }
+    if (probe.status === 2) {
+        return { authenticated: false, error: "fal_not_authenticated" };
+    }
+    return { authenticated: false, error: "fal_api_unreachable" };
+}
+function collectWorkerLocalStatus(input = {}) {
+    const requireGenerationRuntime = input.requireGenerationRuntime ?? (0, runtime_1.readEnvBoolean)("PLAYDROP_WORKER_REQUIRE_GENERATION_RUNTIME", false);
     const degradedReasons = [];
     let codexVersion = null;
     let codexModels = [];
+    let codexImageGenerationAvailable = false;
     let claudeVersion = null;
     let claudeModels = [];
     let grokVersion = null;
@@ -3489,9 +4195,13 @@ function collectWorkerLocalStatus() {
     const npmVersion = null;
     let playwright = null;
     let targetUpdateFailure = null;
+    const workerHomeDir = resolveWorkerHomeDir();
+    const falConfigured = (0, generation_1.hasFalCredential)(workerHomeDir);
+    const falProbe = probeFalAuthentication(workerHomeDir);
     try {
         codexVersion = probeCodexInstallation()?.codexVersion ?? null;
         codexModels = codexVersion ? probeCodexModels() : [];
+        codexImageGenerationAvailable = codexVersion ? probeCodexImageGeneration() : false;
     }
     catch (error) {
         degradedReasons.push(errorCode(error));
@@ -3500,22 +4210,16 @@ function collectWorkerLocalStatus() {
         claudeVersion = probeClaudeInstallation()?.claudeVersion ?? null;
         claudeModels = claudeVersion ? probeClaudeModels() : [];
     }
-    catch (error) {
-        degradedReasons.push(errorCode(error));
-    }
+    catch { }
     try {
         grokVersion = probeGrokInstallation()?.grokVersion ?? null;
         grokModels = grokVersion ? probeGrokModels() : [];
     }
-    catch (error) {
-        degradedReasons.push(errorCode(error));
-    }
+    catch { }
     try {
         cursorVersion = probeCursorInstallation()?.cursorVersion ?? null;
     }
-    catch (error) {
-        degradedReasons.push(errorCode(error));
-    }
+    catch { }
     try {
         playwright = probePlaywrightChromium();
         if (!playwright.chromiumInstalled) {
@@ -3538,6 +4242,9 @@ function collectWorkerLocalStatus() {
             codexVersion,
             codexAuthenticated: codexVersion ? readCodexAuthenticated() : false,
             codexModels,
+            codexImageGenerationAvailable,
+            falConfigured,
+            falAuthenticated: falProbe.authenticated,
             claudeVersion,
             claudeAuthenticated: claudeVersion ? readClaudeAuthenticated() : false,
             claudeModels,
@@ -3550,6 +4257,7 @@ function collectWorkerLocalStatus() {
             playwright,
             runningTaskCount: 0,
             maxParallelTasks: (0, runtime_1.readPositiveEnvInt)("PLAYDROP_WORKER_MAX_PARALLEL_TASKS", DEFAULT_WORKER_MAX_PARALLEL_TASKS),
+            requireGenerationRuntime,
         });
         if (targetUpdateFailure) {
             capabilities.targetUpdateFailure = targetUpdateFailure;
@@ -3564,10 +4272,10 @@ function collectWorkerLocalStatus() {
     const uniqueReasons = Array.from(new Set(degradedReasons));
     const infrastructureFailures = degradedReasons.filter((reason) => reason.startsWith("worker_preflight_"));
     const infrastructureReady = Boolean(playwright?.chromiumInstalled) && infrastructureFailures.length === 0;
-    const ready = Boolean(capabilities?.ready) && infrastructureReady;
+    const ready = Boolean(capabilities?.ready) && infrastructureReady && uniqueReasons.length === 0;
     return {
         ready,
-        degradedReasons: ready ? [] : uniqueReasons,
+        degradedReasons: uniqueReasons,
         cliVersion: (0, clientInfo_1.getCliVersion)(),
         nodeVersion: node_process_1.default.versions.node,
         npmVersion,
@@ -4431,6 +5139,13 @@ function printWorkerStatus(payload) {
     else {
         console.log("  Agents: none detected");
     }
+    const generationProviders = payload.local.capabilities?.generationProviders ?? [];
+    const codexGenerationReady = generationProviders.some((entry) => entry.provider === "CODEX" && entry.ready);
+    const codexImageGenerationReady = generationProviders.some((entry) => entry.provider === "CODEX" && entry.kind === "IMAGE" && entry.ready);
+    const falGenerationReady = generationProviders.some((entry) => entry.provider === "FAL" && entry.ready);
+    console.log(`  Codex generation: ${codexGenerationReady ? "ready" : "unavailable"}`);
+    console.log(`  Codex image generation: ${codexImageGenerationReady ? "ready" : "unavailable"}`);
+    console.log(`  Fal generation: ${falGenerationReady ? "ready" : "unavailable"}`);
     if (payload.local.degradedReasons.length > 0) {
         console.log(`  Reasons: ${payload.local.degradedReasons.join(", ")}`);
     }
@@ -4487,11 +5202,16 @@ async function setupWorker(options = {}) {
             return;
         }
         if (!options.env?.trim()) {
-            throw new Error("worker_setup_requires_env: admin worker setup must pass --env <env> so the LaunchAgent cannot be installed for the wrong environment.");
+            throw new Error("worker_setup_requires_env: cloud worker setup must pass --env <env> so the LaunchAgent cannot be installed for the wrong environment.");
         }
         if (!explicitWorkerName) {
-            throw new Error("worker_setup_requires_name: admin worker setup must pass --name <worker name> so the LaunchAgent identity is deterministic.");
+            throw new Error("worker_setup_requires_name: cloud worker setup must pass --name <worker name> so the LaunchAgent identity is deterministic.");
         }
+        const gameServerInfrastructure = await (0, game_server_infra_1.setupManagedWorkerGameServerInfrastructure)({
+            workerHomeDir: resolveWorkerHomeDir(),
+        });
+        node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_REDIS_ADMIN_URL = gameServerInfrastructure.redisAdminUrl;
+        node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_MONGO_ADMIN_URL = gameServerInfrastructure.mongoAdminUrl;
         verifyNpmGlobalInstallPreconditions();
         const { wrapperPath, policyFile } = await writeManagedWorkerWrapper({ env, workerName, workerKey });
         const { label, plistPath, registrationChanged } = await writeManagedWorkerLaunchAgent({
@@ -4523,7 +5243,7 @@ async function setupWorker(options = {}) {
             `LaunchAgent: ${plistPath}`,
             `Policy file: ${policyFile}`,
         ]);
-    }, { env: options.env });
+    }, { env: options.env, forceRefresh: true });
 }
 async function failTaskWithRetry(client, taskId, body) {
     const terminalReason = body.terminalReason ?? (0, types_1.classifyAgentTaskTerminalReason)(body.error, "worker");
@@ -4553,12 +5273,69 @@ async function failTaskWithRetry(client, taskId, body) {
         }
     }
 }
-async function fetchTaskDetail(client, target, taskId) {
-    if (target === "FIRST_PARTY") {
-        const detail = await client.adminGetAgentTask(taskId);
-        return { task: detail.task };
+async function completeWorkerAgentTaskWithRetry(input) {
+    const sleepImpl = input.sleepImpl ?? sleep;
+    const maxAttempts = input.maxAttempts ?? 3;
+    if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) {
+        throw new Error("agent_task_completion_attempts_invalid");
     }
-    return await client.getAgentTask(taskId);
+    let lastError = new Error("agent_task_completion_failed");
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            return await input.client.workerCompleteAgentTask(input.taskId, input.body);
+        }
+        catch (error) {
+            if (error instanceof types_1.ApiError && error.status < 500)
+                throw error;
+            lastError = error;
+            if (attempt < maxAttempts)
+                await sleepImpl(500 * 2 ** (attempt - 1));
+        }
+    }
+    throw lastError;
+}
+async function fetchTaskDetail(client, target, taskId, workerKey) {
+    try {
+        if (target === "FIRST_PARTY") {
+            return await client.workerGetAgentTask(taskId, { workerKey });
+        }
+        return await client.getAgentTask(taskId);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`agent_task_worker_detail_failed:${detail}`);
+    }
+}
+function classifyWorkerSupervisorFailure(message, stage = "setup") {
+    if (message.startsWith("agent_task_worker_detail_failed:")) {
+        return {
+            kind: "failure",
+            category: "agent_failure",
+            code: "agent_task_worker_detail_failed",
+            message: "The worker could not refresh the task after the agent run. Retry after the platform is healthy.",
+            retryable: true,
+            source: "worker",
+        };
+    }
+    const classified = (0, types_1.classifyAgentTaskTerminalReason)(message, "worker");
+    const stageFailureCodes = {
+        post_agent_detail: "agent_task_post_agent_detail_failed",
+        game_source_reconcile: "agent_task_game_source_reconcile_failed",
+        game_publish: "agent_task_game_publish_failed",
+        task_complete: "agent_task_completion_failed",
+    };
+    const stageFailureCode = stageFailureCodes[stage];
+    if (stageFailureCode && classified.category === "agent_failure" && !classified.retryable) {
+        return {
+            kind: "failure",
+            category: "agent_failure",
+            code: stageFailureCode,
+            message: "The worker failed after the agent finished. Retry after the platform is healthy.",
+            retryable: true,
+            source: "worker",
+        };
+    }
+    return classified;
 }
 function assignmentRequiresRegisteredBundle(assignment) {
     const playdropMetadata = assignment.task.metadata.playdrop;
@@ -4572,7 +5349,8 @@ function throwWorkerRuntimeError(error) {
 }
 async function startWorker(options = {}) {
     loadWorkerEnvFile(options.env);
-    await (0, commandContext_1.withEnvironment)("worker start", "Starting the PlayDrop worker", async ({ client, env, envConfig, token }) => {
+    await (0, commandContext_1.withEnvironment)("worker start", "Starting the PlayDrop worker", async (ctx) => {
+        const { client, env, envConfig } = ctx;
         const devPluginWorkingTree = resolveDevPluginWorkingTree({
             workingTree: options.devPluginWorkingTree,
             env,
@@ -4596,6 +5374,16 @@ async function startWorker(options = {}) {
             throw new Error('worker_session_invalid: the stored session did not resolve to a user. Run "playdrop auth login" and retry.');
         }
         const target = resolveWorkerExecutionTargetFromRole(me.user.role);
+        if (target === "FIRST_PARTY" &&
+            node_process_1.default.env.PLAYDROP_WORKER_WRAPPER_CONTRACT_VERSION &&
+            node_process_1.default.platform === "darwin") {
+            const gameServerInfrastructure = (0, game_server_infra_1.writeManagedWorkerGameServerConfiguration)({
+                workerHomeDir: resolveWorkerHomeDir(),
+            });
+            await (0, game_server_infra_1.probeManagedWorkerGameServerInfrastructure)(gameServerInfrastructure);
+            node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_REDIS_ADMIN_URL = gameServerInfrastructure.redisAdminUrl;
+            node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_MONGO_ADMIN_URL = gameServerInfrastructure.mongoAdminUrl;
+        }
         const initialWorkerPolicy = (await client.listMyAgentWorkers()).updatePolicy;
         if (initialWorkerPolicy.executionTarget !== target) {
             throw new Error(`worker_update_policy_target_mismatch: expected ${target}, received ${initialWorkerPolicy.executionTarget}.`);
@@ -4618,8 +5406,23 @@ async function startWorker(options = {}) {
         const supervisorLock = acquireWorkerSupervisorLock({ supervisorType, workerName });
         try {
             await removeStaleAgentRunCredentials();
+            await (0, game_source_git_1.maintainGameSourceCaches)(resolveWorkerHomeDir()).catch((error) => {
+                console.error(`Game source cache maintenance failed at startup: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            const workerRedisAdminUrl = node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_REDIS_ADMIN_URL?.trim() ?? "";
+            const workerMongoAdminUrl = node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_MONGO_ADMIN_URL?.trim() ?? "";
+            if (target === "FIRST_PARTY" && workerRedisAdminUrl && workerMongoAdminUrl) {
+                const cleaned = await (0, game_server_infra_1.cleanupStaleWorkerGameServerDevResources)({
+                    redisAdminUrl: workerRedisAdminUrl,
+                    mongoAdminUrl: workerMongoAdminUrl,
+                });
+                if (cleaned.redisUsers > 0 || cleaned.redisKeys > 0 || cleaned.mongoDatabases > 0) {
+                    console.log(`Cleaned stale game-server development resources: Redis users=${cleaned.redisUsers}, ` +
+                        `keys=${cleaned.redisKeys}, MongoDB databases=${cleaned.mongoDatabases}.`);
+                }
+            }
             const startupFailures = [];
-            const local = collectWorkerLocalStatus();
+            const local = collectWorkerLocalStatus({ requireGenerationRuntime: target === "FIRST_PARTY" });
             startupFailures.push(...local.degradedReasons);
             if (startupFailures.length > 0 || !local.ready || !local.capabilities || !local.playwright?.chromiumInstalled) {
                 throw formatWorkerPreflightFailure(startupFailures);
@@ -4632,6 +5435,14 @@ async function startWorker(options = {}) {
             };
             const maxParallelTasks = (0, runtime_1.readPositiveEnvInt)("PLAYDROP_WORKER_MAX_PARALLEL_TASKS", DEFAULT_WORKER_MAX_PARALLEL_TASKS);
             let capabilities = local.capabilities;
+            if (target === "FIRST_PARTY" && workerRedisAdminUrl && workerMongoAdminUrl) {
+                capabilities.gameServerDevelopment = {
+                    ready: true,
+                    redisVersion: "7.4.5",
+                    mongoVersion: "8.0.26",
+                    maxParallelTasks,
+                };
+            }
             let lastCapabilityRefreshAt = Date.now();
             let lastProviderTelemetryRefreshAt = 0;
             let providerTelemetryRefresh = null;
@@ -4652,6 +5463,8 @@ async function startWorker(options = {}) {
             let shutdownSignal = null;
             let fatalControlError = null;
             let presenceTimer = null;
+            let authRefreshTimer = null;
+            let durableAuthInvalid = false;
             let currentWorkerPolicy = initialWorkerPolicy;
             const firstActiveTaskId = () => activeTaskIds.values().next().value ?? null;
             const terminateActiveTasks = () => {
@@ -4665,7 +5478,7 @@ async function startWorker(options = {}) {
             });
             const beginProviderTelemetryRefresh = () => {
                 if (providerTelemetryRefresh)
-                    return;
+                    return providerTelemetryRefresh;
                 providerTelemetryRefresh = (0, provider_telemetry_1.probeWorkerProviderTelemetry)(capabilities)
                     .then((telemetry) => {
                     capabilities = (0, provider_telemetry_1.mergeWorkerProviderTelemetry)(capabilities, telemetry);
@@ -4678,6 +5491,7 @@ async function startWorker(options = {}) {
                     lastProviderTelemetryRefreshAt = Date.now();
                     providerTelemetryRefresh = null;
                 });
+                return providerTelemetryRefresh;
             };
             const presenceBody = () => ({
                 workerKey,
@@ -4747,7 +5561,7 @@ async function startWorker(options = {}) {
                 node_process_1.default.stdin.resume();
             }
             console.log(`PlayDrop Worker started as "${workerName}" (${target}).`);
-            beginProviderTelemetryRefresh();
+            await beginProviderTelemetryRefresh();
             // Marks the session expired, kills any in-flight agent child, and lets the
             // run loop finish the task lifecycle before the worker stops non-zero.
             const handleSessionExpiry = () => {
@@ -4758,6 +5572,17 @@ async function startWorker(options = {}) {
                 console.error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
                 terminateActiveTasks();
             };
+            const quiesceForDurableAuthFailure = (error) => {
+                if (durableAuthInvalid)
+                    return;
+                durableAuthInvalid = true;
+                quiescingForUpdate = true;
+                console.error(error instanceof Error ? error.message : String(error));
+                console.error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+            };
+            authRefreshTimer = setInterval(() => {
+                ctx.refreshToken(false).catch(quiesceForDurableAuthFailure);
+            }, 60000);
             try {
                 handleWorkerAction(await client.workerPresence(presenceBody()));
             }
@@ -4809,7 +5634,14 @@ async function startWorker(options = {}) {
                 let agentCompletedAt = null;
                 let agentResult = null;
                 let telemetryReported = false;
+                let gameServerDevLease = null;
+                let gameSourceWorkspace = null;
+                let transcriptSpoolPath = null;
+                let transcriptSpoolSequence = 0;
                 let heartbeatTransientFailures = 0;
+                let automaticContinuationKind = null;
+                let automaticContinuationAttempted = false;
+                let workerFailureStage = "setup";
                 const sendTaskHeartbeat = async () => {
                     try {
                         const heartbeat = await client.workerHeartbeatAgentTask(task.id, { workerKey, leaseToken });
@@ -4830,7 +5662,7 @@ async function startWorker(options = {}) {
                                 clearInterval(heartbeatTimer);
                                 heartbeatTimer = null;
                             }
-                            const refreshed = await fetchTaskDetail(client, target, task.id).catch(() => null);
+                            const refreshed = await fetchTaskDetail(client, target, task.id, workerKey).catch(() => null);
                             if (refreshed?.task.status === "DONE") {
                                 fenced = true;
                                 if (!heartbeatObservedFinalizedTask) {
@@ -4859,7 +5691,7 @@ async function startWorker(options = {}) {
                         console.error(`Agent task heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
                     }
                 };
-                const reportTelemetry = async (status, setupError) => {
+                const reportTelemetry = async (status, setupError, terminalReason) => {
                     const completedAt = agentCompletedAt ?? new Date();
                     await recordAgentRunTelemetry({
                         client,
@@ -4875,11 +5707,20 @@ async function startWorker(options = {}) {
                         observedSkillPaths: [...observedSkillPaths],
                         startedAt: agentStartedAt ?? completedAt,
                         completedAt,
+                        ...(terminalReason ? { terminalReason } : {}),
                     });
                     telemetryReported = true;
                 };
                 const failUploadedArtifactWithoutTaskDone = async () => {
                     const failureCode = "agent_exited_after_upload_without_task_done";
+                    const terminalReason = {
+                        kind: "failure",
+                        category: "agent_failure",
+                        code: failureCode,
+                        message: "The game was uploaded, but the task could not be finalized. Clear this error to continue.",
+                        retryable: false,
+                        source: "worker",
+                    };
                     retainWorkspace = true;
                     await client.workerCreateAgentTaskEvent(task.id, {
                         workerKey,
@@ -4894,21 +5735,73 @@ async function startWorker(options = {}) {
                         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,
-                        },
+                        terminalReason,
+                    });
+                    await reportTelemetry("FAILED", undefined, terminalReason);
+                };
+                const readRecordedTaskUploadFailure = () => {
+                    if (!workspaceDir)
+                        return null;
+                    const failure = readTaskUploadFailureFile(workspaceDir);
+                    if (!failure)
+                        return null;
+                    if (failure.taskId !== task.id || failure.attempt !== taskContext.attempt) {
+                        throw new Error("task_upload_failure_context_mismatch");
+                    }
+                    return failure;
+                };
+                const hasReportedGameSourceCompletion = () => {
+                    if (!assignment.gameSource || task.kind === "STATIC_GAME" || !workspaceDir) {
+                        return false;
+                    }
+                    const intent = readWorkerGameSourceCompletion(workspaceDir);
+                    return intent?.taskId === task.id && intent.attempt === taskContext.attempt;
+                };
+                const taskStillMissingAgentOutcome = (detail) => detail.task.status === "RUNNING" &&
+                    task.kind !== "STATIC_GAME" &&
+                    task.kind !== "RELEASE_SMOKE" &&
+                    !hasReportedGameSourceCompletion();
+                const failMissingAgentOutcome = async (runResult) => {
+                    const terminalReason = missingAgentOutcomeTerminalReason();
+                    retainWorkspace = true;
+                    await client.workerCreateAgentTaskEvent(task.id, {
+                        workerKey,
+                        leaseToken,
+                        kind: "progress",
+                        phase: "failed",
+                        message: terminalReason.message,
+                        pct: null,
+                        payload: { error: terminalReason.code },
+                    });
+                    await failTaskWithRetry(client, task.id, {
+                        workerKey,
+                        leaseToken,
+                        error: terminalReason.code,
+                        terminalReason,
+                        result: runResult,
+                    });
+                    await reportTelemetry("FAILED", undefined, terminalReason);
+                };
+                const failCreationTimeout = async (runResult) => {
+                    const terminalReason = creationTimeoutTerminalReason();
+                    retainWorkspace = true;
+                    await client.workerCreateAgentTaskEvent(task.id, {
+                        workerKey,
+                        leaseToken,
+                        kind: "progress",
+                        phase: "failed",
+                        message: terminalReason.message,
+                        pct: null,
+                        payload: { error: terminalReason.code },
+                    });
+                    await failTaskWithRetry(client, task.id, {
+                        workerKey,
+                        leaseToken,
+                        error: terminalReason.code,
+                        terminalReason,
+                        result: runResult,
                     });
-                    await reportTelemetry("FAILED");
+                    await reportTelemetry("FAILED", undefined, terminalReason);
                 };
                 try {
                     await sendTaskHeartbeat();
@@ -4936,6 +5829,25 @@ async function startWorker(options = {}) {
                         codexModel?.model ?? claudeModel?.model ?? grokModel?.model ?? assignment.agent.model;
                     reasoningEffort = codexModel?.reasoningEffort ?? claudeModel?.effort ?? grokModel?.reasoningEffort ?? null;
                     const cleanRoom = task.kind === "STATIC_GAME";
+                    if (task.kind === "NEW_GAME" || task.kind === "REMIX_GAME" || task.kind === "GAME_UPDATE") {
+                        const managedRedisAdminUrl = node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_REDIS_ADMIN_URL?.trim() ?? "";
+                        const managedMongoAdminUrl = node_process_1.default.env.PLAYDROP_WORKER_GAME_SERVER_MONGO_ADMIN_URL?.trim() ?? "";
+                        const redisAdminUrl = managedRedisAdminUrl || node_process_1.default.env.PLAYDROP_DEV_REDIS_URL?.trim() || "";
+                        const mongoAdminUrl = managedMongoAdminUrl || node_process_1.default.env.PLAYDROP_DEV_MONGO_URL?.trim() || "";
+                        if (target === "FIRST_PARTY" && (!redisAdminUrl || !mongoAdminUrl)) {
+                            throw new Error("worker_game_server_dev_infrastructure_missing");
+                        }
+                        if (redisAdminUrl && mongoAdminUrl) {
+                            gameServerDevLease = await (0, game_server_infra_1.provisionWorkerGameServerDevLease)({
+                                taskId: task.id,
+                                attempt: taskContext.attempt,
+                                environment: env,
+                                redisAdminUrl,
+                                mongoAdminUrl,
+                                requireRedisAcl: Boolean(managedRedisAdminUrl),
+                            });
+                        }
+                    }
                     workspaceDir = workerTaskWorkspaceDirFromAssignment(assignment);
                     const preparedWorkspace = await prepareClaimedTaskWorkspace({
                         workspaceDir,
@@ -4944,11 +5856,30 @@ async function startWorker(options = {}) {
                     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;
+                    if (assignment.gameSource) {
+                        gameSourceWorkspace = await (0, game_source_git_1.setupGameSourceWorkspace)({
+                            assignment,
+                            workspaceDir,
+                            workerHomeDir: resolveWorkerHomeDir(),
+                            client,
+                            workerKey,
+                            leaseToken,
+                        });
+                    }
+                    agentWorkspaceDir = gameSourceWorkspace?.projectDir ?? (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) {
+                    transcriptSpoolPath = node_path_1.default.join(workspaceDir, ".playdrop", `transcript-attempt-${taskContext.attempt}.jsonl`);
+                    if (!(0, node_fs_1.existsSync)(transcriptSpoolPath)) {
+                        await (0, promises_1.writeFile)(transcriptSpoolPath, `${JSON.stringify({
+                            version: 1,
+                            taskId: task.id,
+                            attempt: taskContext.attempt,
+                            createdAt: new Date().toISOString(),
+                        })}\n`, "utf8");
+                    }
+                    if (!cleanRoom || assignment.gameSource) {
                         await stageWorkerTaskContext({
                             workspaceDir,
                             env,
@@ -4963,6 +5894,7 @@ async function startWorker(options = {}) {
                             taskId: taskContext.taskId,
                             attempt: taskContext.attempt,
                             devPort,
+                            gameSourceGit: Boolean(assignment.gameSource),
                         });
                     const handleEventDrainFailure = (error) => {
                         const classification = classifyWorkerEventDrainError(error);
@@ -4991,11 +5923,20 @@ async function startWorker(options = {}) {
                             }
                         }
                     };
-                    const appendTranscriptChunks = async (chunks) => {
+                    const appendTranscriptSpool = async (chunks) => {
                         appendObservedSkillPathsFromTranscript(chunks);
-                        await appendWorkerTranscriptChunks({ client, taskId: task.id, workerKey, leaseToken, chunks });
+                        if (transcriptSpoolPath) {
+                            const lines = chunks.map((chunk) => JSON.stringify({
+                                sequence: ++transcriptSpoolSequence,
+                                stream: chunk.stream,
+                                content: chunk.content,
+                                createdAt: new Date().toISOString(),
+                            })).join("\n");
+                            if (lines)
+                                await (0, promises_1.appendFile)(transcriptSpoolPath, `${lines}\n`, "utf8");
+                        }
                     };
-                    await stageAssignmentWorkspaceV3(agentWorkspaceDir, assignment.workspace);
+                    await stageAssignmentWorkspace(agentWorkspaceDir, assignment.workspace);
                     if (fenced) {
                         throw new Error("agent_task_lease_invalid");
                     }
@@ -5030,7 +5971,7 @@ async function startWorker(options = {}) {
                         }
                         const taskClient = (0, apiClient_1.createCliApiClient)({
                             baseUrl: envConfig.apiBase,
-                            token,
+                            tokenProvider: ctx.getToken,
                             onBehalfCreatorUsername: taskContext.creatorUsername,
                             agentTaskToken: assignment.task.token,
                             agentTaskId: task.id,
@@ -5047,7 +5988,7 @@ async function startWorker(options = {}) {
                             webBase: envConfig.webBase ?? null,
                             cdnBase: envConfig.cdnBase,
                             devRouterPort: devPort,
-                            token,
+                            token: ctx.getToken(),
                             user: me.user,
                             skipReview: true,
                         });
@@ -5105,7 +6046,7 @@ async function startWorker(options = {}) {
                     }, 1000);
                     const gameCreationTask = usesCreatorRecovery(task.kind);
                     const startsInCreationRecovery = gameCreationTask && preparedWorkspace.resumed;
-                    const prompt = startsInCreationRecovery
+                    const basePrompt = startsInCreationRecovery
                         ? buildCreatorRecoveryPrompt({
                             prompt: assignment.request.prompt,
                             kind: task.kind,
@@ -5113,6 +6054,7 @@ async function startWorker(options = {}) {
                         : task.kind === "GAME_EVAL" && preparedWorkspace.resumed
                             ? buildGameEvalRetryPrompt(assignment.request.prompt)
                             : assignment.request.prompt;
+                    const prompt = basePrompt;
                     const imageAttachments = assignment.request.attachments
                         .filter((attachment) => attachment.contentType.startsWith("image/"))
                         .map((attachment) => ({
@@ -5144,6 +6086,28 @@ async function startWorker(options = {}) {
                         }
                     };
                     const runAssignedAgent = async (input) => {
+                        const fixtureKind = (0, e2e_fixtures_1.detectPlaydropE2EFixture)(assignment.request.prompt);
+                        if (fixtureKind) {
+                            if (!(0, e2e_fixtures_1.isPlaydropE2EGameKind)(task.kind) || fixtureKind !== task.kind) {
+                                throw new Error(`playdrop_e2e_marker_kind_mismatch:expected_${task.kind}:received_${fixtureKind}`);
+                            }
+                            if (!assignment.gameSource || !gameSourceWorkspace || !workspaceDir || !agentWorkspaceDir) {
+                                throw new Error("playdrop_e2e_game_source_git_required");
+                            }
+                            return runPlaydropE2EGameFixture({
+                                projectDir: agentWorkspaceDir,
+                                workspaceDir,
+                                binDir,
+                                eventDir,
+                                envName: env,
+                                devPort,
+                                workerUsername: username,
+                                taskContext,
+                                gameServerDev: gameServerDevLease,
+                                onTranscriptChunks: appendTranscriptSpool,
+                                onChild: handleAgentChild,
+                            });
+                        }
                         if (assignment.agent.runtime === "CODEX") {
                             return runCodex({
                                 workspaceDir: agentWorkspaceDir,
@@ -5155,18 +6119,21 @@ async function startWorker(options = {}) {
                                 workerUsername: username,
                                 taskId: task.id,
                                 taskToken: assignment.task.token,
+                                taskAccessToken: assignment.task.accessToken ?? null,
                                 attempt: taskContext.attempt,
                                 devPort,
+                                gameServerDev: gameServerDevLease,
                                 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);
+                                    await appendTranscriptSpool(chunks);
                                 },
                                 onChild: handleAgentChild,
                                 cleanRoom,
+                                allowGit: Boolean(assignment.gameSource),
                                 timeoutMs: input.timeoutMs,
                                 resumeSessionId: input.resumeSessionId,
                             });
@@ -5185,16 +6152,19 @@ async function startWorker(options = {}) {
                                 workerUsername: username,
                                 taskId: task.id,
                                 taskToken: assignment.task.token,
+                                taskAccessToken: assignment.task.accessToken ?? null,
                                 attempt: taskContext.attempt,
                                 devPort,
+                                gameServerDev: gameServerDevLease,
                                 claudeModel: claudeModel ?? resolveClaudeModel(assignment.agent.model),
                                 taskPluginRoot: assignmentPluginRoot,
                                 imageAttachments,
                                 onTranscriptChunks: async (chunks) => {
-                                    await appendTranscriptChunks(chunks);
+                                    await appendTranscriptSpool(chunks);
                                 },
                                 onChild: handleAgentChild,
                                 cleanRoom,
+                                allowGit: Boolean(assignment.gameSource),
                                 timeoutMs: input.timeoutMs,
                                 resumeSessionId: input.resumeSessionId,
                             });
@@ -5213,15 +6183,17 @@ async function startWorker(options = {}) {
                                 workerUsername: username,
                                 taskId: task.id,
                                 taskToken: assignment.task.token,
+                                taskAccessToken: assignment.task.accessToken ?? null,
                                 attempt: taskContext.attempt,
                                 devPort,
+                                gameServerDev: gameServerDevLease,
                                 grokModel: grokModel ?? resolveGrokModel(assignment.agent.model),
                                 taskPluginRoot: assignmentPluginRoot,
                                 imageAttachments,
                                 enablePlaywrightMcp: assignment.agent.browser === "PLAYWRIGHT",
                                 instrumentSurface: resolveWorkerInstrumentSurface(taskContext),
                                 onTranscriptChunks: async (chunks) => {
-                                    await appendTranscriptChunks(chunks);
+                                    await appendTranscriptSpool(chunks);
                                 },
                                 onChild: handleAgentChild,
                                 cleanRoom,
@@ -5251,6 +6223,7 @@ async function startWorker(options = {}) {
                             message: "Resumed the retained game workspace with a focused creation recovery window.",
                         });
                     }
+                    workerFailureStage = "agent";
                     agentResult = await runAssignedAgent({
                         prompt,
                         timeoutMs: startsInCreationRecovery
@@ -5259,6 +6232,7 @@ async function startWorker(options = {}) {
                                 ? runtime_1.DEFAULT_CREATOR_AGENT_TIMEOUT_MS
                                 : undefined,
                     });
+                    workerFailureStage = "post_agent_detail";
                     if (startsInCreationRecovery && agentResult.timedOut) {
                         const marker = "agent_task_creation_recovery_timeout";
                         agentResult = {
@@ -5269,9 +6243,10 @@ async function startWorker(options = {}) {
                     }
                     if (gameCreationTask && !startsInCreationRecovery && agentResult.timedOut && !fenced && !shuttingDown) {
                         const timedOutResult = agentResult;
-                        const refreshedAfterTimeout = await fetchTaskDetail(client, target, task.id);
+                        const refreshedAfterTimeout = await fetchTaskDetail(client, target, task.id, workerKey);
                         if (refreshedAfterTimeout.task.status === "RUNNING" &&
                             !hasAgentTaskUploadedArtifact(refreshedAfterTimeout.task)) {
+                            automaticContinuationKind = "timeout";
                             const providerSessionId = timedOutResult.providerSessionId?.trim() ?? "";
                             if (!providerSessionId) {
                                 const marker = "agent_task_resume_session_missing";
@@ -5282,6 +6257,7 @@ async function startWorker(options = {}) {
                                 };
                             }
                             else {
+                                automaticContinuationAttempted = true;
                                 await client.workerCreateAgentTaskEvent(task.id, {
                                     workerKey,
                                     leaseToken,
@@ -5301,15 +6277,67 @@ async function startWorker(options = {}) {
                             }
                         }
                     }
+                    if (!automaticContinuationKind) {
+                        const refreshedAfterExit = await fetchTaskDetail(client, target, task.id, workerKey);
+                        if (shouldRecoverMissingAgentOutcome({
+                            kind: task.kind,
+                            taskStatus: refreshedAfterExit.task.status,
+                            completionReported: hasReportedGameSourceCompletion(),
+                            result: agentResult,
+                        })) {
+                            automaticContinuationKind = "missing_outcome";
+                            const initialResult = agentResult;
+                            const providerSessionId = initialResult.providerSessionId?.trim() ?? "";
+                            if (!providerSessionId) {
+                                const marker = "agent_task_outcome_recovery_session_missing";
+                                agentResult = {
+                                    ...initialResult,
+                                    stderr: `${initialResult.stderr}\n${marker}`.trim(),
+                                    outputTail: `${initialResult.outputTail}\n${marker}`.trim(),
+                                };
+                            }
+                            else {
+                                automaticContinuationAttempted = true;
+                                await client.workerCreateAgentTaskEvent(task.id, {
+                                    workerKey,
+                                    leaseToken,
+                                    kind: "progress",
+                                    phase: "outcome_recovery",
+                                    message: "The agent stopped before confirming the result. Asking it to resume and finish the task.",
+                                });
+                                const recoveryResult = await runAssignedAgent({
+                                    prompt: buildMissingAgentOutcomeRecoveryPrompt(task.kind),
+                                    timeoutMs: runtime_1.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS,
+                                    resumeSessionId: providerSessionId,
+                                });
+                                agentResult = mergeMissingAgentOutcomeRecoveryResults(assignment.agent.runtime, initialResult, recoveryResult);
+                            }
+                        }
+                    }
                     resolvedRuntimeModel = agentResult.providerResolvedModel?.trim() || resolvedRuntimeModel;
                     agentCompletedAt = new Date();
                     await queueEventDrain().catch((error) => {
                         handleEventDrainFailure(error);
                     });
+                    void archiveWorkerTranscriptBestEffort({
+                        client,
+                        taskId: task.id,
+                        attempt: taskContext.attempt,
+                        workerKey,
+                        leaseToken,
+                        transcriptPath: transcriptSpoolPath,
+                    });
                     const completedAgentResult = agentResult;
                     const agentRunResult = buildAgentRunResult(completedAgentResult);
+                    if (assignment.gameSource &&
+                        gameSourceWorkspace &&
+                        (completedAgentResult.timedOut || completedAgentResult.exitCode !== 0 || completedAgentResult.signal)) {
+                        await (0, game_source_git_1.checkpointFailedGameSourceWorkspace)({ workspace: gameSourceWorkspace, taskId: task.id }).catch((error) => {
+                            console.error(`Failed Git workspace checkpoint did not complete: ${error instanceof Error ? error.message : String(error)}`);
+                        });
+                    }
                     if (fenced) {
-                        const refreshed = await fetchTaskDetail(client, target, task.id).catch(() => null);
+                        const refreshed = await fetchTaskDetail(client, target, task.id, workerKey).catch(() => null);
                         if (refreshed && refreshed.task.status !== "RUNNING" && refreshed.task.status !== "QUEUED") {
                             retainWorkspace = refreshed.task.status === "FAILED";
                             console.error(`Agent task ${task.id} was finalized by the server as ${refreshed.task.status}.`);
@@ -5330,18 +6358,20 @@ async function startWorker(options = {}) {
                         });
                     }
                     else if (shuttingDown) {
+                        const terminalReason = (0, types_1.classifyAgentTaskTerminalReason)("worker_shutdown", "worker");
                         await failTaskWithRetry(client, task.id, {
                             workerKey,
                             leaseToken,
                             error: "worker_shutdown",
+                            terminalReason,
                             result: agentRunResult,
                         });
-                        await reportTelemetry("FAILED");
+                        await reportTelemetry("FAILED", undefined, terminalReason);
                     }
                     else if (completedAgentResult.timedOut ||
                         completedAgentResult.exitCode !== 0 ||
                         completedAgentResult.signal) {
-                        const refreshed = await fetchTaskDetail(client, target, task.id);
+                        const refreshed = await fetchTaskDetail(client, target, task.id, workerKey);
                         if (refreshed.task.status !== "RUNNING") {
                             retainWorkspace = refreshed.task.status === "FAILED";
                             console.error(`Agent task ${task.id} was finalized by the agent as ${refreshed.task.status}.`);
@@ -5351,19 +6381,32 @@ async function startWorker(options = {}) {
                             console.error(`Agent task ${task.id} uploaded an artifact but exited before task completion; failing it explicitly.`);
                             await failUploadedArtifactWithoutTaskDone();
                         }
+                        else if (automaticContinuationKind === "missing_outcome" &&
+                            taskStillMissingAgentOutcome(refreshed)) {
+                            await failMissingAgentOutcome(agentRunResult);
+                        }
+                        else if (automaticContinuationKind === "timeout" &&
+                            taskStillMissingAgentOutcome(refreshed) &&
+                            !automaticContinuationAttempted) {
+                            await failCreationTimeout(agentRunResult);
+                        }
                         else {
                             retainWorkspace = true;
-                            const failureCode = buildAgentFailureCode(assignment.agent.runtime, completedAgentResult, {
-                                model: assignment.agent.model,
-                                reasoningEffort,
-                            });
-                            const availabilityReason = classifyAgentAvailabilityFailureReason(failureCode);
+                            const uploadFailure = readRecordedTaskUploadFailure();
+                            const failureCode = uploadFailure?.terminalReason.code ??
+                                buildAgentFailureCode(assignment.agent.runtime, completedAgentResult, {
+                                    model: assignment.agent.model,
+                                    reasoningEffort,
+                                });
+                            const availabilityReason = uploadFailure
+                                ? null
+                                : classifyAgentAvailabilityFailureReason(failureCode, task.kind === "GAME_REVIEW");
                             await client.workerCreateAgentTaskEvent(task.id, {
                                 workerKey,
                                 leaseToken,
                                 kind: "progress",
                                 phase: "failed",
-                                message: describeAgentFailureForEvent(failureCode),
+                                message: uploadFailure?.terminalReason.message ?? describeAgentFailureForEvent(failureCode),
                                 pct: null,
                                 payload: { error: failureCode },
                             });
@@ -5388,7 +6431,9 @@ async function startWorker(options = {}) {
                                     workerKey,
                                     leaseToken,
                                     error: failureCode,
-                                    terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(failureCode, "agent"),
+                                    terminalReason: uploadFailure
+                                        ? uploadFailure.terminalReason
+                                        : (0, types_1.classifyAgentTaskTerminalReason)(failureCode, "agent"),
                                     result: agentRunResult,
                                 });
                                 await reportTelemetry("FAILED");
@@ -5396,18 +6441,237 @@ async function startWorker(options = {}) {
                         }
                     }
                     else {
-                        const refreshed = await fetchTaskDetail(client, target, task.id);
+                        const refreshed = await fetchTaskDetail(client, target, task.id, workerKey);
                         if (refreshed.task.status !== "RUNNING") {
                             retainWorkspace = refreshed.task.status === "FAILED";
                             console.error(`Agent task ${task.id} was finalized by the agent as ${refreshed.task.status}.`);
                             await reportTelemetry(refreshed.task.status);
                         }
-                        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,
+                        else if (taskStillMissingAgentOutcome(refreshed) &&
+                            hasAgentTaskUploadedArtifact(refreshed.task)) {
+                            console.error(`Agent task ${task.id} uploaded an artifact but exited before task completion; failing it explicitly.`);
+                            await failUploadedArtifactWithoutTaskDone();
+                        }
+                        else if (automaticContinuationKind === "timeout" &&
+                            taskStillMissingAgentOutcome(refreshed)) {
+                            await failCreationTimeout(agentRunResult);
+                        }
+                        else if (automaticContinuationKind === "missing_outcome" &&
+                            taskStillMissingAgentOutcome(refreshed)) {
+                            await failMissingAgentOutcome(agentRunResult);
+                        }
+                        else if (assignment.gameSource) {
+                            if (!gameSourceWorkspace || !workspaceDir || !agentWorkspaceDir) {
+                                throw new Error("game_source_workspace_missing");
+                            }
+                            const intent = task.kind === "STATIC_GAME"
+                                ? {
+                                    taskId: task.id,
+                                    attempt: taskContext.attempt,
+                                    summary: "Created and privately hosted a standalone static web game.",
+                                }
+                                : readWorkerGameSourceCompletion(workspaceDir);
+                            if (!intent || intent.taskId !== task.id || intent.attempt !== taskContext.attempt) {
+                                throw new Error("agent_exited_without_task_done");
+                            }
+                            if (task.kind !== "STATIC_GAME" && !(0, node_fs_1.existsSync)(workerGameSourceReadinessPath(workspaceDir))) {
+                                throw new Error("agent_exited_without_task_upload");
+                            }
+                            if (task.kind === "STATIC_GAME" && !(0, node_fs_1.existsSync)(node_path_1.default.join(agentWorkspaceDir, "catalogue.json"))) {
+                                const primarySurface = resolveWorkerInstrumentSurface(taskContext);
+                                if (!primarySurface)
+                                    throw new Error("static_game_artifact_primary_surface_missing");
+                                if (!envConfig.cdnBase)
+                                    throw new Error("static_game_publish_cdn_base_missing");
+                                const preparedStatic = await (0, staticHtml_1.prepareStaticHtmlProject)({
+                                    projectDir: agentWorkspaceDir,
+                                    taskId: task.id,
+                                    appName: refreshed.task.claimedAppName ?? undefined,
+                                    primarySurface,
+                                    cdnBase: envConfig.cdnBase,
+                                });
+                                try {
+                                    const sourceTask = preparedStatic.sourceTask;
+                                    await (0, promises_1.writeFile)(node_path_1.default.join(agentWorkspaceDir, "catalogue.json"), `${JSON.stringify({
+                                        apps: [{
+                                                name: sourceTask.name,
+                                                version: sourceTask.version,
+                                                displayName: sourceTask.displayName,
+                                                subtitle: sourceTask.subtitle,
+                                                description: sourceTask.description,
+                                                type: "GAME",
+                                                authMode: "NONE",
+                                                controllerMode: "UNSUPPORTED",
+                                                previewable: true,
+                                                file: "index.html",
+                                                primarySurface,
+                                                surfaceTargets: {
+                                                    desktop: sourceTask.surfaceTargets.includes("DESKTOP"),
+                                                    mobileLandscape: sourceTask.surfaceTargets.includes("MOBILE_LANDSCAPE"),
+                                                    mobilePortrait: sourceTask.surfaceTargets.includes("MOBILE_PORTRAIT"),
+                                                },
+                                                releaseNotes: sourceTask.releaseNotes,
+                                                hostingMode: "HOSTED",
+                                                license: "CLOSED",
+                                            }],
+                                    }, null, 2)}\n`, "utf8");
+                                }
+                                finally {
+                                    await preparedStatic.cleanup();
+                                }
+                            }
+                            const outputProjectDir = discoverWorkerProjectRoot(agentWorkspaceDir);
+                            if (node_path_1.default.resolve(outputProjectDir) !== node_path_1.default.resolve(gameSourceWorkspace.projectDir)) {
+                                throw new Error("game_source_output_must_be_repository_root");
+                            }
+                            workerFailureStage = "game_source_reconcile";
+                            const reconciled = await (0, game_source_git_1.reconcileGameSourceWorkspace)({
+                                workspace: gameSourceWorkspace,
+                                taskId: task.id,
+                                summary: intent.summary,
+                            });
+                            const taskClient = (0, apiClient_1.createCliApiClient)({
+                                baseUrl: envConfig.apiBase,
+                                tokenProvider: ctx.getToken,
+                                onBehalfCreatorUsername: taskContext.creatorUsername,
+                                agentTaskToken: assignment.task.token,
+                                agentTaskId: task.id,
+                                agentTaskAttempt: taskContext.attempt,
+                            });
+                            let published;
+                            let finalizedGameSource = null;
+                            let preparedGameSource = null;
+                            const prepareGitTransition = async (input) => {
+                                const versionParts = input.version.split(".").map((part) => Number(part));
+                                if (versionParts.length !== 3 ||
+                                    versionParts.some((part) => !Number.isSafeInteger(part) || part < 0)) {
+                                    throw new Error("game_source_version_invalid");
+                                }
+                                finalizedGameSource = await (0, game_source_git_1.finalizeGameSourceRepository)({
+                                    reconciled,
+                                    appVersionId: 0,
+                                    version: { major: versionParts[0], minor: versionParts[1], patch: versionParts[2] },
+                                });
+                                preparedGameSource = await (0, game_source_git_1.uploadFinalizedGameSource)({
+                                    client,
+                                    taskId: task.id,
+                                    attempt: taskContext.attempt,
+                                    workerKey,
+                                    leaseToken,
+                                    appId: input.appId,
+                                    appUploadSessionId: input.sessionId,
+                                    source: finalizedGameSource,
+                                });
+                                return {
+                                    commitSha: preparedGameSource.commitSha,
+                                    headSha: preparedGameSource.headSha,
+                                    baseGeneration: preparedGameSource.baseGeneration,
+                                    bundleStorageKey: preparedGameSource.bundleStorageKey,
+                                    bundleSha256: preparedGameSource.bundleSha256,
+                                    bundleSizeBytes: preparedGameSource.bundleBytes,
+                                };
+                            };
+                            workerFailureStage = "game_publish";
+                            if (task.kind === "STATIC_GAME") {
+                                const primarySurface = resolveWorkerInstrumentSurface(taskContext);
+                                if (!primarySurface)
+                                    throw new Error("static_game_artifact_primary_surface_missing");
+                                if (!envConfig.cdnBase)
+                                    throw new Error("static_game_publish_cdn_base_missing");
+                                const result = 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,
+                                    cdnBase: envConfig.cdnBase,
+                                    claimedAppName: refreshed.task.claimedAppName,
+                                    devRouterPort: devPort,
+                                    token: ctx.getToken(),
+                                    user: me.user,
+                                    prepareGitTransition,
+                                });
+                                published = result;
+                            }
+                            else {
+                                const fixtureKind = (0, e2e_fixtures_1.detectPlaydropE2EFixture)(assignment.request.prompt);
+                                const result = await (0, upload_1.publishWorkerAppProject)({
+                                    client: taskClient,
+                                    taskId: task.id,
+                                    taskToken: assignment.task.token,
+                                    kind: task.kind,
+                                    executionTarget: task.executionTarget,
+                                    expectedAppName: taskContext.outputAppName ?? undefined,
+                                    expectedDisplayName: taskContext.outputDisplayName,
+                                    expectedSubtitle: taskContext.outputSubtitle,
+                                    expectedPrimarySurface: taskContext.outputPrimarySurface,
+                                    remixSourceRef: taskContext.remixSourceRef ?? null,
+                                    projectDir: agentWorkspaceDir,
+                                    creatorUsername: taskContext.creatorUsername,
+                                    apiBase: envConfig.apiBase,
+                                    webBase: envConfig.webBase ?? null,
+                                    token: ctx.getToken(),
+                                    user: me.user,
+                                    deterministicE2EFixture: fixtureKind === task.kind,
+                                    prepareGitTransition,
+                                });
+                                published = result;
+                            }
+                            if (!finalizedGameSource || !preparedGameSource) {
+                                throw new Error("game_source_transition_not_prepared");
+                            }
+                            const finalized = finalizedGameSource;
+                            const gameSource = preparedGameSource;
+                            workerFailureStage = "task_complete";
+                            const completion = await completeWorkerAgentTaskWithRetry({
+                                client,
+                                taskId: task.id,
+                                body: {
+                                    workerKey,
+                                    leaseToken,
+                                    appId: published.appId,
+                                    appVersionId: published.appVersionId,
+                                    result: {
+                                        appId: published.appId,
+                                        appVersionId: published.appVersionId,
+                                        appName: published.appName,
+                                        version: published.version,
+                                        versionNodeId: published.versionNodeId,
+                                        completedBy: "worker_game_source_git",
+                                    },
+                                    summary: intent.summary,
+                                    ...(intent.nextSteps ? { nextSteps: intent.nextSteps } : {}),
+                                    ...(intent.platformFeedback ? { platformFeedback: intent.platformFeedback } : {}),
+                                    tokensUsed: agentResult.tokensUsed,
+                                    gameSource,
+                                },
+                            });
+                            if (!completion.gameSource)
+                                throw new Error("game_source_completion_metadata_missing");
+                            (0, game_source_git_1.emitGameSourceWorkerEvent)("playdrop.game_source.completed", {
+                                taskId: task.id,
+                                appId: published.appId,
+                                repoGeneration: completion.gameSource.repoGeneration,
+                                bundleBytes: finalized.bundle.length,
+                                materialCount: finalized.materials.length,
+                                outcome: "DONE",
                             });
+                            await reportTelemetry("DONE");
+                            await (0, game_source_git_1.cleanupCompletedGameSourceWorkspace)({
+                                workspace: gameSourceWorkspace,
+                                workerHomeDir: resolveWorkerHomeDir(),
+                                appId: published.appId,
+                                repoGeneration: completion.gameSource.repoGeneration,
+                                headSha: finalized.commitSha,
+                                versions: finalized.versions,
+                            });
+                            retainWorkspace = false;
+                            console.log(`Agent task ${task.id} reconciled, published, and completed with canonical Git source.`);
+                        }
+                        else if (task.kind === "STATIC_GAME") {
                             await reportTelemetry("DONE");
                             try {
                                 let appId = refreshed.task.appId;
@@ -5452,7 +6716,7 @@ async function startWorker(options = {}) {
                                     });
                                     const taskClient = (0, apiClient_1.createCliApiClient)({
                                         baseUrl: envConfig.apiBase,
-                                        token,
+                                        tokenProvider: ctx.getToken,
                                         onBehalfCreatorUsername: taskContext.creatorUsername,
                                         agentTaskToken: assignment.task.token,
                                         agentTaskId: task.id,
@@ -5470,7 +6734,7 @@ async function startWorker(options = {}) {
                                         cdnBase: envConfig.cdnBase,
                                         claimedAppName: refreshed.task.claimedAppName,
                                         devRouterPort: devPort,
-                                        token,
+                                        token: ctx.getToken(),
                                         user: me.user,
                                     });
                                     appId = published.appId;
@@ -5521,9 +6785,9 @@ async function startWorker(options = {}) {
                                     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 },
+                                        ? "Static game output did not pass validation."
+                                        : "Static game publishing failed.",
+                                    payload: { error: failureCode },
                                 });
                                 retainWorkspace = true;
                                 const terminalReason = artifactFailure
@@ -5533,7 +6797,6 @@ async function startWorker(options = {}) {
                                         code: failureCode,
                                         message: "The static game output did not pass validation.",
                                         retryable: false,
-                                        rawError: rawMessage,
                                         source: "worker",
                                     }
                                     : {
@@ -5542,7 +6805,6 @@ async function startWorker(options = {}) {
                                         code: failureCode,
                                         message: "The platform failed to publish the static game.",
                                         retryable: true,
-                                        rawError: rawMessage,
                                         source: "worker",
                                     };
                                 await failTaskWithRetry(client, task.id, {
@@ -5550,11 +6812,6 @@ async function startWorker(options = {}) {
                                     leaseToken,
                                     error: failureCode,
                                     terminalReason,
-                                    result: {
-                                        stage: artifactFailure ? "artifact" : "publish",
-                                        error: rawMessage,
-                                        agentRunSucceeded: true,
-                                    },
                                 });
                             }
                         }
@@ -5563,44 +6820,20 @@ async function startWorker(options = {}) {
                             await failUploadedArtifactWithoutTaskDone();
                         }
                         else {
-                            const tokenCap = (0, runtime_1.readPositiveEnvInt)("PLAYDROP_WORKER_TOKEN_CAP", runtime_1.DEFAULT_WORKER_TOKEN_CAP);
-                            let tokenUsageKnown = true;
-                            try {
-                                tokenUsageKnown = (0, runtime_1.assertWorkerTokenUsageWithinCap)({
-                                    tokensUsed: agentResult.tokensUsed,
-                                    tokenCap,
-                                });
-                            }
-                            catch (error) {
-                                await client.workerCreateAgentTaskEvent(task.id, {
-                                    workerKey,
-                                    leaseToken,
-                                    kind: "progress",
-                                    message: `Token usage ${completedAgentResult.tokensUsed} exceeded the worker token cap of ${tokenCap}.`,
-                                });
-                                await reportTelemetry("FAILED");
-                                throw error;
-                            }
-                            if (!tokenUsageKnown) {
-                                await client.workerCreateAgentTaskEvent(task.id, {
-                                    workerKey,
-                                    leaseToken,
-                                    kind: "progress",
-                                    message: "Token usage parse failed: the agent output did not contain a recognizable total token count.",
-                                });
-                            }
+                            const uploadFailure = readRecordedTaskUploadFailure();
                             await client.workerCreateAgentTaskEvent(task.id, {
                                 workerKey,
                                 leaseToken,
                                 kind: "progress",
                                 phase: "failed",
-                                message: "Agent exited before running playdrop task done",
+                                message: uploadFailure?.terminalReason.message ?? "Agent exited before running playdrop task done",
                             });
                             retainWorkspace = true;
                             await failTaskWithRetry(client, task.id, {
                                 workerKey,
                                 leaseToken,
-                                error: "agent_exited_without_task_done",
+                                error: uploadFailure?.terminalReason.code ?? "agent_exited_without_task_done",
+                                ...(uploadFailure ? { terminalReason: uploadFailure.terminalReason } : {}),
                                 result: agentRunResult,
                             });
                             await reportTelemetry("FAILED");
@@ -5609,23 +6842,45 @@ async function startWorker(options = {}) {
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
+                    if (gameSourceWorkspace) {
+                        await (0, game_source_git_1.checkpointFailedGameSourceWorkspace)({ workspace: gameSourceWorkspace, taskId: task.id }).catch((checkpointError) => {
+                            console.error(`Failed Git workspace checkpoint did not complete: ${checkpointError instanceof Error ? checkpointError.message : String(checkpointError)}`);
+                        });
+                    }
                     if (isAgentTaskNotRunningError(error)) {
-                        const refreshed = await fetchTaskDetail(client, target, task.id).catch(() => null);
+                        const refreshed = await fetchTaskDetail(client, target, task.id, workerKey).catch(() => null);
                         retainWorkspace = refreshed?.task.status === "FAILED";
                         console.error(`Agent task ${task.id} was already finalized${refreshed ? ` as ${refreshed.task.status}` : ""}.`);
                     }
                     else {
                         retainWorkspace = true;
+                        const failureCode = normalizeWorkerFailureErrorCode(message);
+                        const terminalReason = classifyWorkerSupervisorFailure(message, workerFailureStage);
                         console.error(`Agent task ${task.id} failed in the worker: ${message}`);
+                        await client.workerCreateAgentTaskEvent(task.id, {
+                            workerKey,
+                            leaseToken,
+                            kind: "system",
+                            phase: "worker_failed",
+                            message: terminalReason.message,
+                            pct: null,
+                            payload: {
+                                stage: workerFailureStage,
+                                error: failureCode.slice(0, 160),
+                            },
+                        }).catch((eventError) => {
+                            console.error(`Agent task ${task.id} worker failure event did not record: ${eventError instanceof Error ? eventError.message : String(eventError)}`);
+                        });
                     }
                     if (!fenced && !isAgentTaskNotRunningError(error)) {
                         try {
+                            const failureCode = normalizeWorkerFailureErrorCode(message);
+                            const terminalReason = classifyWorkerSupervisorFailure(message, workerFailureStage);
                             await failTaskWithRetry(client, task.id, {
                                 workerKey,
                                 leaseToken,
-                                error: normalizeWorkerFailureErrorCode(message),
-                                terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(message, "worker"),
-                                result: { workerError: message },
+                                error: failureCode,
+                                terminalReason,
                             });
                         }
                         catch (reportError) {
@@ -5634,7 +6889,7 @@ async function startWorker(options = {}) {
                         finally {
                             if (!telemetryReported) {
                                 try {
-                                    await reportTelemetry("FAILED", message);
+                                    await reportTelemetry("FAILED", undefined, classifyWorkerSupervisorFailure(message, workerFailureStage));
                                 }
                                 catch (telemetryError) {
                                     console.error(`Agent task telemetry failed: ${telemetryError instanceof Error ? telemetryError.message : String(telemetryError)}`);
@@ -5651,6 +6906,7 @@ async function startWorker(options = {}) {
                         clearInterval(eventDrainTimer);
                     }
                     activeTerminators.delete(task.id);
+                    await gameServerDevLease?.cleanup();
                     if (workspaceDir) {
                         await removeAgentRunCredentials(workspaceDir);
                     }
@@ -5660,6 +6916,9 @@ async function startWorker(options = {}) {
                     else if (workspaceDir) {
                         await (0, promises_1.rm)(workspaceDir, { recursive: true, force: true });
                     }
+                    await (0, game_source_git_1.maintainGameSourceCaches)(resolveWorkerHomeDir()).catch((error) => {
+                        console.error(`Game source cache maintenance failed after task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    });
                 }
                 if (sessionExpired) {
                     throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
@@ -5684,6 +6943,7 @@ async function startWorker(options = {}) {
                             npmVersion,
                             playwright,
                             maxParallelTasks,
+                            requireGenerationRuntime: target === "FIRST_PARTY",
                         }), capabilities);
                         lastCapabilityRefreshAt = Date.now();
                         console.log("Worker refreshed installed agent CLI versions and model catalogs.");
@@ -5699,7 +6959,7 @@ async function startWorker(options = {}) {
                     });
                     let claim;
                     try {
-                        claim = normalizeWorkerClaimResponseV3(await client.workerClaimAgentTask(buildWorkerClaimBody({
+                        claim = normalizeWorkerClaimResponseV5(await client.workerClaimAgentTask(buildWorkerClaimBody({
                             workerKey,
                             capabilities,
                             runningTaskCount: activeTaskRuns.size,
@@ -5744,10 +7004,29 @@ async function startWorker(options = {}) {
                         continue;
                     }
                     activeTaskIds.add(taskId);
-                    activeDevPorts.add(devPort);
+                    if (claim.assignment.operation === "GAME")
+                        activeDevPorts.add(devPort);
+                    const run = claim.assignment.operation === "GENERATION"
+                        ? (0, generation_1.runWorkerGenerationTask)({
+                            client,
+                            assignment: claim.assignment,
+                            workerKey,
+                            leaseToken: acknowledgedLease.token,
+                            workerHomeDir: resolveWorkerHomeDir(),
+                        })
+                        : claim.assignment.operation === "SCREENING"
+                            ? (0, generation_1.runWorkerScreeningTask)({
+                                client,
+                                assignment: claim.assignment,
+                                workerKey,
+                                leaseToken: acknowledgedLease.token,
+                            })
+                            : claim.assignment.operation === "GAME"
+                                ? runClaimedTask(claim.assignment, acknowledgedLease.token, devPort)
+                                : Promise.reject(new Error("worker_assignment_operation_invalid"));
                     const taskRun = containWorkerTaskRun({
                         taskId,
-                        run: runClaimedTask(claim.assignment, acknowledgedLease.token, devPort),
+                        run,
                     })
                         .finally(() => {
                         activeTaskRuns.delete(taskId);
@@ -5772,6 +7051,9 @@ async function startWorker(options = {}) {
                 if (sessionExpired) {
                     throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
                 }
+                if (durableAuthInvalid) {
+                    throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+                }
                 if (quiescingForUpdate) {
                     console.log("Worker quiesced for managed update. Exiting for supervisor restart.");
                     return;
@@ -5788,6 +7070,9 @@ async function startWorker(options = {}) {
                 if (presenceTimer) {
                     clearInterval(presenceTimer);
                 }
+                if (authRefreshTimer) {
+                    clearInterval(authRefreshTimer);
+                }
                 node_process_1.default.off("SIGINT", signalHandler);
                 node_process_1.default.off("SIGTERM", signalHandler);
                 if (options.superviseStdin) {
@@ -5800,7 +7085,7 @@ async function startWorker(options = {}) {
         finally {
             releaseWorkerSupervisorLock(supervisorLock);
         }
-    }, { env: options.env });
+    }, { env: options.env, forceRefresh: true });
 }
 async function reportTask(options) {
     const message = options.message?.trim() || null;
@@ -5852,11 +7137,11 @@ async function prepareAssetRuntimeTask() {
     }
     const workspaceDir = resolveTaskWorkspaceDir();
     const relativeSetupPath = node_path_1.default.join("skills", "make-2d-asset-pack", "scripts", "setup_runtime.py");
-    const setupScript = [
-        node_path_1.default.join(workspaceDir, ".playdrop", "task-plugin", relativeSetupPath),
-        node_path_1.default.join(workspaceDir, ".playdrop", "dev-task-plugin", relativeSetupPath),
-    ].find((candidate) => isFile(candidate));
-    if (!setupScript) {
+    const assignmentSetupScript = node_path_1.default.join(workspaceDir, ".playdrop", "task-plugin", relativeSetupPath);
+    const setupScript = isFile(assignmentSetupScript)
+        ? assignmentSetupScript
+        : node_path_1.default.join(discoverWorkerProjectRoot(node_process_1.default.cwd()), ".playdrop", "dev-task-plugin", relativeSetupPath);
+    if (!isFile(setupScript)) {
         throw new Error("task_asset_runtime_setup_script_missing");
     }
     const bootstrapPython = node_process_1.default.env.PLAYDROP_ASSET_PACK_BOOTSTRAP_PYTHON?.trim() || "python3";
@@ -6049,8 +7334,11 @@ async function resolveTaskCommandContext(command, optionsEnv, taskContext) {
     if (!ctx) {
         return null;
     }
+    const accessToken = taskContext.target === "FIRST_PARTY" ? taskContext.taskAccessToken?.trim() ?? "" : ctx.token;
+    if (!accessToken)
+        throw new Error("agent_task_access_token_missing");
     const taskClientOptions = {
-        token: ctx.token,
+        token: accessToken,
         onBehalfCreatorUsername: taskContext.creatorUsername,
         agentTaskToken: taskContext.taskToken,
         agentTaskId: taskContext.taskId,
@@ -6060,21 +7348,42 @@ async function resolveTaskCommandContext(command, optionsEnv, taskContext) {
         ...taskClientOptions,
         baseUrl: ctx.envConfig.apiBase,
     });
-    const aiClient = (0, apiClient_1.createCliAiClient)({
-        ...taskClientOptions,
-        baseUrl: ctx.envConfig.aiBase,
-    });
-    const me = await client.me();
-    if (!me.user) {
+    const user = taskContext.target === "FIRST_PARTY"
+        ? readAgentTaskAccessIdentity(accessToken, taskContext)
+        : (await client.me()).user;
+    if (!user)
         throw new Error("task_context_user_missing");
+    return { ...ctx, token: accessToken, client, user };
+}
+function readAgentTaskAccessIdentity(token, taskContext) {
+    try {
+        const payloadSegment = token.split(".")[1];
+        if (!payloadSegment)
+            throw new Error("missing_payload");
+        const payload = JSON.parse(Buffer.from(payloadSegment, "base64url").toString("utf8"));
+        const id = Number(payload.sub);
+        const username = typeof payload.username === "string" ? payload.username.trim() : "";
+        const expiresAtSeconds = Number(payload.exp);
+        if (payload.tokenKind !== "agent_task_access" ||
+            payload.role !== "CLOUD_WORKER" ||
+            payload.kind !== "AGENT" ||
+            !Number.isInteger(id) ||
+            id <= 0 ||
+            !username ||
+            Number(payload.taskId) !== taskContext.taskId ||
+            Number(payload.taskAttempt) !== taskContext.attempt ||
+            !Number.isFinite(expiresAtSeconds) ||
+            expiresAtSeconds <= Date.now() / 1000) {
+            throw new Error("invalid_claims");
+        }
+        return { id, username, role: "CLOUD_WORKER", kind: "AGENT" };
+    }
+    catch {
+        throw new Error("agent_task_access_token_invalid");
     }
-    return { ...ctx, client, aiClient, user: me.user };
 }
 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");
     }
@@ -6113,22 +7422,12 @@ async function uploadTask(options = {}) {
         (0, output_1.printSuccess)(`Task upload preflight passed for ${result.creatorUsername}/${result.appName}. Upload can start.`);
         return;
     }
-    if ((0, node_fs_1.existsSync)(workerTaskUploadResultPath(workspaceDir))) {
-        const existingResult = readTaskUploadResultFile(workspaceDir);
-        assertTaskUploadResultMatchesContext({
-            taskContext,
-            uploadResult: existingResult,
-        });
-        (0, output_1.printSuccess)(`Task upload already completed for ${existingResult.creatorUsername}/${existingResult.appName} version ${existingResult.version}. Run "playdrop task done" to close the task.`);
-        return;
-    }
-    await withTaskUploadLock(workspaceDir, async () => {
+    if (taskContext.gameSourceGit) {
         const ctx = await resolveTaskCommandContext("task upload", options.env, taskContext);
-        if (!ctx) {
+        if (!ctx)
             return;
-        }
         const projectDir = discoverWorkerProjectRoot(node_process_1.default.cwd());
-        const published = await (0, upload_1.publishWorkerAppProject)({
+        const result = await (0, upload_1.preflightWorkerAppProject)({
             client: ctx.client,
             taskId: taskContext.taskId,
             taskToken: taskContext.taskToken,
@@ -6146,6 +7445,63 @@ async function uploadTask(options = {}) {
             token: ctx.token,
             user: ctx.user,
         });
+        await (0, promises_1.writeFile)(workerGameSourceReadinessPath(workspaceDir), JSON.stringify({
+            taskId: taskContext.taskId,
+            attempt: taskContext.attempt,
+            projectDir,
+            readyAt: new Date().toISOString(),
+        }, null, 2));
+        for (const warning of result.warnings)
+            console.error(`Preflight warning: ${warning}`);
+        (0, output_1.printSuccess)("Task source is ready. Run \"playdrop task done\" when the work is complete.");
+        return;
+    }
+    if (taskContext.kind === "STATIC_GAME") {
+        throw new Error("task_upload_not_allowed_for_static_game");
+    }
+    if ((0, node_fs_1.existsSync)(workerTaskUploadResultPath(workspaceDir))) {
+        const existingResult = readTaskUploadResultFile(workspaceDir);
+        assertTaskUploadResultMatchesContext({
+            taskContext,
+            uploadResult: existingResult,
+        });
+        (0, output_1.printSuccess)(`Task upload already completed for ${existingResult.creatorUsername}/${existingResult.appName} version ${existingResult.version}. Run "playdrop task done" to close the task.`);
+        return;
+    }
+    await withTaskUploadLock(workspaceDir, async () => {
+        const ctx = await resolveTaskCommandContext("task upload", options.env, taskContext);
+        if (!ctx) {
+            return;
+        }
+        const projectDir = discoverWorkerProjectRoot(node_process_1.default.cwd());
+        await (0, promises_1.rm)(workerTaskUploadFailurePath(workspaceDir), { force: true });
+        let published;
+        try {
+            published = await (0, upload_1.publishWorkerAppProject)({
+                client: ctx.client,
+                taskId: taskContext.taskId,
+                taskToken: taskContext.taskToken,
+                kind: uploadKind,
+                executionTarget: taskContext.target,
+                expectedAppName: taskContext.outputAppName ?? undefined,
+                expectedDisplayName: taskContext.outputDisplayName,
+                expectedSubtitle: taskContext.outputSubtitle,
+                expectedPrimarySurface: taskContext.outputPrimarySurface,
+                remixSourceRef: taskContext.remixSourceRef ?? null,
+                projectDir,
+                creatorUsername: taskContext.creatorUsername,
+                apiBase: ctx.envConfig.apiBase,
+                webBase: ctx.envConfig.webBase ?? null,
+                token: ctx.token,
+                user: ctx.user,
+            });
+        }
+        catch (error) {
+            await recordTaskUploadFailure({ workspaceDir, taskContext, error }).catch((recordError) => {
+                console.error(`Could not record task upload failure: ${recordError instanceof Error ? recordError.message : String(recordError)}`);
+            });
+            throw error;
+        }
         const result = {
             taskId: taskContext.taskId,
             appId: published.appId,
@@ -6216,6 +7572,7 @@ async function claimSlugTask(options) {
 async function completeTask(options) {
     const taskContext = readTaskContextFile();
     const workspaceDir = resolveTaskWorkspaceDir();
+    const commandInputDir = taskContext.gameSourceGit ? node_process_1.default.cwd() : workspaceDir;
     if (taskContext.kind === "GAME_REVIEW" || taskContext.kind === "GAME_EVAL") {
         throw new Error("task_done_not_allowed_for_game_review");
     }
@@ -6226,11 +7583,38 @@ async function completeTask(options) {
     if (summary.length > 200) {
         throw new Error("task_done_summary_too_long:max_200_characters");
     }
+    if (taskContext.gameSourceGit) {
+        if (!(0, node_fs_1.existsSync)(workerGameSourceReadinessPath(workspaceDir)))
+            throw new Error("task_done_source_not_ready");
+        const ctx = await resolveTaskCommandContext("task done", options.env, taskContext);
+        if (!ctx)
+            return;
+        const nextSteps = await readTaskNextStepsFileForCommand({
+            filePath: options.nextSteps,
+            workspaceDir: commandInputDir,
+            command: "task done",
+            ctx,
+            taskContext,
+        });
+        if (nextSteps === NEXT_STEPS_READ_FAILED)
+            return;
+        const platformFeedback = readPlatformFeedbackFile(options.platformFeedbackFile, commandInputDir);
+        const intent = {
+            taskId: taskContext.taskId,
+            attempt: taskContext.attempt,
+            summary,
+            ...(nextSteps !== undefined ? { nextSteps } : {}),
+            ...(platformFeedback ? { platformFeedback } : {}),
+        };
+        await (0, promises_1.writeFile)(workerGameSourceCompletionPath(workspaceDir), `${JSON.stringify(intent, null, 2)}\n`, "utf8");
+        (0, output_1.printSuccess)("Task completion recorded. The worker will reconcile and publish the source after the agent exits.");
+        return;
+    }
+    const uploadResult = readTaskUploadResultFile();
     const ctx = await resolveTaskCommandContext("task done", options.env, taskContext);
     if (!ctx) {
         return;
     }
-    const uploadResult = readTaskUploadResultFile();
     const appId = uploadResult.appId;
     const appVersionId = uploadResult.appVersionId;
     if (!appId || !appVersionId) {
@@ -6275,12 +7659,6 @@ async function completeTask(options) {
                 taskToken: taskContext.taskToken,
                 error: "remix_relation_missing",
                 terminalReason: (0, types_1.classifyAgentTaskTerminalReason)("upload_validation:remix_relation_missing", "agent"),
-                result: {
-                    appId: uploadResult.appId,
-                    appVersionId: uploadResult.appVersionId,
-                    appName: uploadResult.appName,
-                    version: uploadResult.version,
-                },
                 ...(platformFeedback ? { platformFeedback } : {}),
             });
         }
@@ -6543,11 +7921,6 @@ async function instrumentErrorTask(options) {
         taskToken: taskContext.taskToken,
         error: `instrument_error:${reason}`,
         terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(`instrument_error:${reason}`, "instrument"),
-        result: {
-            outcome: "instrument_error",
-            reason,
-            reportedBy: "agent",
-        },
     });
     (0, output_1.printSuccess)(`Instrument error submitted (${reason}). This was the final operation; stop immediately.`);
 }
@@ -6570,22 +7943,26 @@ async function failTask(options) {
     }
     const taskContext = readTaskContextFile();
     const workspaceDir = resolveTaskWorkspaceDir();
+    const uploadFailure = readTaskUploadFailureFile(workspaceDir);
+    if (uploadFailure && (uploadFailure.taskId !== taskContext.taskId || uploadFailure.attempt !== taskContext.attempt)) {
+        throw new Error("task_upload_failure_context_mismatch");
+    }
     const ctx = await resolveTaskCommandContext("task fail", options.env, taskContext);
     if (!ctx) {
         return;
     }
     const platformFeedback = readPlatformFeedbackFile(options.platformFeedbackFile, workspaceDir);
-    const terminalReason = (0, types_1.classifyAgentTaskTerminalReason)(message, "agent");
+    const classifiedMessage = (0, types_1.classifyAgentTaskTerminalReason)(message, "agent");
+    const terminalReason = uploadFailure?.terminalReason ?? {
+        ...classifiedMessage,
+        message: "The agent reported that it could not complete the task.",
+        retryable: options.retryableWithSameInput === true,
+        source: "agent",
+    };
     await ctx.client.workerFailAgentTask(taskContext.taskId, {
         taskToken: taskContext.taskToken,
-        error: message,
-        terminalReason: {
-            ...terminalReason,
-            message,
-            retryable: options.retryableWithSameInput === true,
-            source: "agent",
-        },
-        result: { failedBy: "agent" },
+        error: uploadFailure?.terminalReason.code ?? terminalReason.code,
+        terminalReason,
         ...(platformFeedback ? { platformFeedback } : {}),
     });
     (0, output_1.printSuccess)("Task marked failed. This was the final operation; send one short final status sentence and stop immediately.");