@playdrop/playdrop-cli 0.17.2 → 0.17.5

package/dist/commands/worker.js

@@ -150,6 +150,7 @@ 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 game_source_commands_1 = require("./worker/game-source-commands");
 const generation_1 = require("./worker/generation");
 const e2e_fixtures_1 = require("./worker/e2e-fixtures");
 var archive_staging_2 = require("./worker/archive-staging");
@@ -1241,9 +1242,6 @@ function workerTaskUploadFailurePath(workspaceDir) {
 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");
 }
@@ -5636,6 +5634,11 @@ async function startWorker(options = {}) {
                 let telemetryReported = false;
                 let gameServerDevLease = null;
                 let gameSourceWorkspace = null;
+                let gameSourceCommandServer = null;
+                let gameSourcePublication = null;
+                let previousGameSourceCommitSha;
+                let preparedGameSourceProposal = null;
+                let completedGameSourceGeneration = null;
                 let transcriptSpoolPath = null;
                 let transcriptSpoolSequence = 0;
                 let heartbeatTransientFailures = 0;
@@ -5643,6 +5646,8 @@ async function startWorker(options = {}) {
                 let automaticContinuationAttempted = false;
                 let workerFailureStage = "setup";
                 const sendTaskHeartbeat = async () => {
+                    if (completedGameSourceGeneration)
+                        return;
                     try {
                         const heartbeat = await client.workerHeartbeatAgentTask(task.id, { workerKey, leaseToken });
                         heartbeatTransientFailures = 0;
@@ -5708,6 +5713,8 @@ async function startWorker(options = {}) {
                         startedAt: agentStartedAt ?? completedAt,
                         completedAt,
                         ...(terminalReason ? { terminalReason } : {}),
+                    }).catch((error) => {
+                        console.error(`Agent task ${task.id} telemetry could not be recorded: ${error instanceof Error ? error.message : String(error)}`);
                     });
                     telemetryReported = true;
                 };
@@ -5803,6 +5810,255 @@ async function startWorker(options = {}) {
                     });
                     await reportTelemetry("FAILED", undefined, terminalReason);
                 };
+                // The supervisor keeps the lease, but both commands wait for the real
+                // operation while the agent can still read errors, repair, and retry.
+                const publishGameSourceForAgent = async () => {
+                    if (gameSourcePublication)
+                        return gameSourcePublication.upload;
+                    if (fenced || shuttingDown)
+                        throw new Error("agent_task_lease_invalid");
+                    if (!gameSourceWorkspace || !workspaceDir || !agentWorkspaceDir) {
+                        throw new Error("game_source_workspace_missing");
+                    }
+                    const currentTask = await fetchTaskDetail(client, target, task.id, workerKey);
+                    if (currentTask.task.status !== "RUNNING")
+                        throw new Error("agent_task_not_running");
+                    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: currentTask.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: `Prepared ${taskContext.outputAppName ?? "game"} for publication`,
+                        previousCommitSha: previousGameSourceCommitSha,
+                    });
+                    previousGameSourceCommitSha = reconciled.commitSha;
+                    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");
+                        }
+                        // A finalize response can be lost after the version is saved. An
+                        // unchanged retry must keep that exact source transition, not a
+                        // new timestamped commit or bundle. This cache is attempt-local.
+                        if (preparedGameSourceProposal?.appId === input.appId &&
+                            preparedGameSourceProposal.version === input.version &&
+                            preparedGameSourceProposal.finalized.commitSha === reconciled.commitSha) {
+                            finalizedGameSource = preparedGameSourceProposal.finalized;
+                        }
+                        else {
+                            finalizedGameSource = await (0, game_source_git_1.finalizeGameSourceRepository)({
+                                reconciled,
+                                appVersionId: 0,
+                                version: { major: versionParts[0], minor: versionParts[1], patch: versionParts[2] },
+                            });
+                            preparedGameSourceProposal = {
+                                appId: input.appId,
+                                version: input.version,
+                                finalized: finalizedGameSource,
+                            };
+                        }
+                        // Recheck ownership and generation for this upload session, even
+                        // when the immutable bundle is reused after an aborted session.
+                        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: currentTask.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,
+                            devRouterPort: devPort,
+                            deterministicE2EFixture: fixtureKind === task.kind,
+                            prepareGitTransition,
+                        });
+                        published = result;
+                    }
+                    if (!finalizedGameSource || !preparedGameSource) {
+                        throw new Error("game_source_transition_not_prepared");
+                    }
+                    const finalized = finalizedGameSource;
+                    const gameSource = preparedGameSource;
+                    if (!published.versionNodeId)
+                        throw new Error("game_source_version_node_missing");
+                    const upload = {
+                        taskId: task.id,
+                        appId: published.appId,
+                        appVersionId: published.appVersionId,
+                        appName: published.appName,
+                        version: published.version,
+                        versionNodeId: published.versionNodeId,
+                        creatorUsername: taskContext.creatorUsername,
+                    };
+                    gameSourcePublication = { upload, source: gameSource, finalized };
+                    await (0, promises_1.writeFile)(workerTaskUploadResultPath(workspaceDir), JSON.stringify(upload, null, 2), "utf8");
+                    await (0, promises_1.rm)(workerTaskUploadFailurePath(workspaceDir), { force: true });
+                    for (const warning of published.warnings)
+                        console.error(`Upload warning: ${warning}`);
+                    return upload;
+                };
+                const completeGameSourceForAgent = async (intent) => {
+                    if (completedGameSourceGeneration)
+                        return;
+                    if (fenced || shuttingDown)
+                        throw new Error("agent_task_lease_invalid");
+                    if (!gameSourcePublication)
+                        throw new Error("task_done_missing_upload_result: Run playdrop task upload successfully first.");
+                    if (intent.taskId !== task.id || intent.attempt !== taskContext.attempt ||
+                        typeof intent.summary !== "string" || !intent.summary.trim() ||
+                        intent.summary.length > 200 || /[\r\n]/.test(intent.summary)) {
+                        throw new Error("game_source_completion_intent_invalid");
+                    }
+                    const { upload: published, source: gameSource, finalized } = gameSourcePublication;
+                    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 } : {}),
+                            ...(agentResult ? { tokensUsed: agentResult.tokensUsed } : {}),
+                            gameSource,
+                        },
+                    });
+                    if (!completion.gameSource)
+                        throw new Error("game_source_completion_metadata_missing");
+                    completedGameSourceGeneration = completion.gameSource.repoGeneration;
+                    (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",
+                    });
+                    retainWorkspace = false;
+                };
                 try {
                     await sendTaskHeartbeat();
                     if (sessionExpired) {
@@ -5896,13 +6152,18 @@ async function startWorker(options = {}) {
                             devPort,
                             gameSourceGit: Boolean(assignment.gameSource),
                         });
-                    const handleEventDrainFailure = (error) => {
+                    const handleEventDrainFailure = async (error) => {
+                        if (completedGameSourceGeneration)
+                            return;
                         const classification = classifyWorkerEventDrainError(error);
                         if (classification === "session_expired") {
                             handleSessionExpiry();
                             return;
                         }
                         if (classification === "lease_invalid") {
+                            const current = await fetchTaskDetail(client, target, task.id, workerKey).catch(() => null);
+                            if (current?.task.status === "DONE")
+                                return;
                             fenced = true;
                             activeTerminators.get(task.id)?.();
                             return;
@@ -5910,7 +6171,10 @@ async function startWorker(options = {}) {
                         console.error(`Agent task event drain failed: ${error instanceof Error ? error.message : String(error)}`);
                     };
                     const queueEventDrain = () => {
-                        eventDrainPromise = eventDrainPromise.then(() => drainWorkerEventQueue({ eventDir, client, taskId: task.id, workerKey, leaseToken }), () => drainWorkerEventQueue({ eventDir, client, taskId: task.id, workerKey, leaseToken }));
+                        const drain = () => completedGameSourceGeneration
+                            ? Promise.resolve()
+                            : drainWorkerEventQueue({ eventDir, client, taskId: task.id, workerKey, leaseToken });
+                        eventDrainPromise = eventDrainPromise.then(drain, drain);
                         return eventDrainPromise;
                     };
                     const appendObservedSkillPathsFromTranscript = (chunks) => {
@@ -6041,7 +6305,7 @@ async function startWorker(options = {}) {
                     }
                     eventDrainTimer = setInterval(() => {
                         queueEventDrain().catch((error) => {
-                            handleEventDrainFailure(error);
+                            return handleEventDrainFailure(error);
                         });
                     }, 1000);
                     const gameCreationTask = usesCreatorRecovery(task.kind);
@@ -6078,7 +6342,7 @@ async function startWorker(options = {}) {
                         try {
                             enqueueWorkerEvent(eventDir, initialProgress);
                             queueEventDrain().catch((error) => {
-                                handleEventDrainFailure(error);
+                                return handleEventDrainFailure(error);
                             });
                         }
                         catch (error) {
@@ -6223,6 +6487,31 @@ async function startWorker(options = {}) {
                             message: "Resumed the retained game workspace with a focused creation recovery window.",
                         });
                     }
+                    if (assignment.gameSource && task.kind !== "STATIC_GAME") {
+                        gameSourceCommandServer = await (0, game_source_commands_1.startWorkerGameSourceCommandServer)({
+                            workspaceDir,
+                            taskId: task.id,
+                            attempt: taskContext.attempt,
+                            onCommand: async (request) => {
+                                try {
+                                    if (request.command === "upload")
+                                        return await publishGameSourceForAgent();
+                                    if (!request.payload || typeof request.payload !== "object") {
+                                        throw new Error("game_source_completion_intent_invalid");
+                                    }
+                                    await completeGameSourceForAgent(request.payload);
+                                    return { completed: true };
+                                }
+                                catch (error) {
+                                    await recordTaskUploadFailure({ workspaceDir: workspaceDir, taskContext, error }).catch((recordError) => console.error(`Could not record task command failure: ${recordError}`));
+                                    throw error;
+                                }
+                                finally {
+                                    workerFailureStage = "agent";
+                                }
+                            },
+                        });
+                    }
                     workerFailureStage = "agent";
                     agentResult = await runAssignedAgent({
                         prompt,
@@ -6314,10 +6603,12 @@ async function startWorker(options = {}) {
                             }
                         }
                     }
+                    await gameSourceCommandServer?.close();
+                    gameSourceCommandServer = null;
                     resolvedRuntimeModel = agentResult.providerResolvedModel?.trim() || resolvedRuntimeModel;
                     agentCompletedAt = new Date();
                     await queueEventDrain().catch((error) => {
-                        handleEventDrainFailure(error);
+                        return handleEventDrainFailure(error);
                     });
                     void archiveWorkerTranscriptBestEffort({
                         client,
@@ -6461,216 +6752,16 @@ async function startWorker(options = {}) {
                             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") {
+                                throw new Error("agent_exited_without_successful_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,
+                            await publishGameSourceForAgent();
+                            await completeGameSourceForAgent({
                                 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,
-                                    devRouterPort: devPort,
-                                    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",
+                                attempt: taskContext.attempt,
+                                summary: "Created and privately hosted a standalone static web game.",
                             });
                             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");
@@ -6843,6 +6934,8 @@ async function startWorker(options = {}) {
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
+                    await gameSourceCommandServer?.close();
+                    gameSourceCommandServer = null;
                     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)}`);
@@ -6900,6 +6993,7 @@ async function startWorker(options = {}) {
                     }
                 }
                 finally {
+                    await gameSourceCommandServer?.close();
                     if (heartbeatTimer) {
                         clearInterval(heartbeatTimer);
                     }
@@ -6908,6 +7002,20 @@ async function startWorker(options = {}) {
                     }
                     activeTerminators.delete(task.id);
                     await gameServerDevLease?.cleanup();
+                    if (completedGameSourceGeneration && gameSourcePublication && gameSourceWorkspace) {
+                        const publication = gameSourcePublication;
+                        await (0, game_source_git_1.cleanupCompletedGameSourceWorkspace)({
+                            workspace: gameSourceWorkspace,
+                            workerHomeDir: resolveWorkerHomeDir(),
+                            appId: publication.upload.appId,
+                            repoGeneration: completedGameSourceGeneration,
+                            headSha: publication.finalized.commitSha,
+                            versions: publication.finalized.versions,
+                        }).catch((cleanupError) => {
+                            retainWorkspace = true;
+                            console.error(`Completed game source cache cleanup failed: ${cleanupError}`);
+                        });
+                    }
                     if (workspaceDir) {
                         await removeAgentRunCredentials(workspaceDir);
                     }
@@ -7424,37 +7532,20 @@ async function uploadTask(options = {}) {
         return;
     }
     if (taskContext.gameSourceGit) {
-        const ctx = await resolveTaskCommandContext("task upload", options.env, taskContext);
-        if (!ctx)
-            return;
-        const projectDir = discoverWorkerProjectRoot(node_process_1.default.cwd());
-        const result = await (0, upload_1.preflightWorkerAppProject)({
-            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,
+        await withTaskUploadLock(workspaceDir, async () => {
+            const ctx = await resolveTaskCommandContext("task upload", options.env, taskContext);
+            if (!ctx)
+                return;
+            await (0, game_source_commands_1.requestWorkerGameSourceCommand)({
+                workspaceDir,
+                taskId: taskContext.taskId,
+                attempt: taskContext.attempt,
+                command: "upload",
+            });
+            const result = readTaskUploadResultFile(workspaceDir);
+            assertTaskUploadResultMatchesContext({ taskContext, uploadResult: result });
+            (0, output_1.printSuccess)(`Uploaded ${result.creatorUsername}/${result.appName} version ${result.version}. Run "playdrop task done" to close the task.`);
         });
-        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") {
@@ -7586,8 +7677,8 @@ async function completeTask(options) {
         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 uploadResult = readTaskUploadResultFile(workspaceDir);
+        assertTaskUploadResultMatchesContext({ taskContext, uploadResult });
         const ctx = await resolveTaskCommandContext("task done", options.env, taskContext);
         if (!ctx)
             return;
@@ -7608,8 +7699,20 @@ async function completeTask(options) {
             ...(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.");
+        await withTaskUploadLock(workspaceDir, async () => {
+            const result = await (0, game_source_commands_1.requestWorkerGameSourceCommand)({
+                workspaceDir,
+                taskId: taskContext.taskId,
+                attempt: taskContext.attempt,
+                command: "done",
+                payload: intent,
+            });
+            if (!result || typeof result !== "object" || !("completed" in result) || result.completed !== true) {
+                throw new Error("game_source_completion_response_invalid");
+            }
+            await (0, promises_1.writeFile)(workerGameSourceCompletionPath(workspaceDir), `${JSON.stringify(intent, null, 2)}\n`, "utf8");
+        });
+        (0, output_1.printSuccess)("Task marked done.");
         return;
     }
     const uploadResult = readTaskUploadResultFile();
@@ -7957,7 +8060,7 @@ async function failTask(options) {
     const classifiedMessage = (0, types_1.classifyAgentTaskTerminalReason)(message, "agent");
     const terminalReason = uploadFailure?.terminalReason ?? {
         ...classifiedMessage,
-        message: "The agent reported that it could not complete the task.",
+        message,
         retryable: options.retryableWithSameInput === true,
         source: "agent",
     };