@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/commands/worker/provider-telemetry.js

@@ -21,7 +21,7 @@ const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const PROVIDER_TELEMETRY_TIMEOUT_MS = 10000;
 const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
 const WEEKLY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
-const WEEKLY_USAGE_RESERVE_PERCENT = 10;
+const WEEKLY_USAGE_RESERVE_PERCENT = 5;
 function asObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }

package/dist/commands/worker/runtime.d.ts

@@ -1,7 +1,6 @@
 export declare const DEFAULT_CODEX_TIMEOUT_MS: number;
 export declare const DEFAULT_CREATOR_AGENT_TIMEOUT_MS: number;
 export declare const DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS: number;
-export declare const DEFAULT_WORKER_TOKEN_CAP = 20000000;
 export declare const DEFAULT_CODEX_LOG_TAIL_CHARS = 12000;
 export declare const DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = 10000;
 export type LoggedProcessResult = {
@@ -48,10 +47,6 @@ export type CodexRolloutTokenUsageReadOptions = {
 };
 export declare function readCodexRolloutTokenUsageForThread(threadId: string, options?: CodexRolloutTokenUsageReadOptions): Promise<AgentTokenUsage>;
 export declare function extractCodexTokensUsed(output: string): number | null;
-export declare function assertWorkerTokenUsageWithinCap(input: {
-    tokensUsed: number | null;
-    tokenCap: number;
-}): boolean;
 export declare function runLoggedProcess(input: {
     command: string;
     args: string[];
@@ -71,8 +66,6 @@ export declare function buildCodexExecArgs(input: {
     workspaceDir: string;
     model: string;
     reasoningEffort: string;
-    networkAccess: boolean;
-    sandboxMode?: CodexSandboxMode;
     imagePaths?: string[];
     resumeSessionId?: string | null;
 }): string[];
@@ -84,8 +77,6 @@ export declare function buildGrokExecArgs(input: {
     reasoningEffort: string;
     resumeSessionId?: string | null;
 }): string[];
-export type CodexSandboxMode = "danger-full-access" | "workspace-write" | "read-only";
-export declare function readCodexSandboxMode(env?: NodeJS.ProcessEnv): CodexSandboxMode;
 export declare function buildClaudeExecArgs(input: {
     model: string;
     effort?: string | null;
@@ -96,6 +87,7 @@ export declare function buildClaudeExecArgs(input: {
     denyReadRoots?: string[] | null;
     pluginDir?: string | null;
     playdropCliEnabled?: boolean;
+    allowGit?: boolean;
     resumeSessionId?: string | null;
 }): string[];
 export declare const PLAYWRIGHT_MCP_VERSION = "0.0.78";
@@ -110,13 +102,14 @@ export declare function buildClaudePermissionSettings(input?: {
     workspaceDir?: string | null;
     denyReadRoots?: string[];
     playdropCliEnabled?: boolean;
+    allowGit?: boolean;
 }): {
     permissions: {
         allow: string[];
         deny: string[];
     };
 };
-export declare function buildClaudeDeniedPermissionRules(denyReadRoots?: string[]): string[];
+export declare function buildClaudeDeniedPermissionRules(denyReadRoots?: string[], allowGit?: boolean): string[];
 export declare function buildWorkerChildEnv(input: {
     binDir: string;
     workerHomeDir: string;
@@ -131,6 +124,11 @@ export declare function buildWorkerChildEnv(input: {
     claudeConfigDir?: string;
     playdropConfigPath?: string;
     playwrightBrowsersPath?: string;
+    gameServerDev?: {
+        redisUrl: string;
+        mongoUrl: string;
+        redisNamespace: string;
+    };
     baseEnv?: NodeJS.ProcessEnv;
 }): NodeJS.ProcessEnv;
 export declare function buildCleanRoomChildEnv(input: {

package/dist/commands/worker/runtime.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAYWRIGHT_MCP_VERSION = exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = exports.DEFAULT_CODEX_LOG_TAIL_CHARS = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
+exports.PLAYWRIGHT_MCP_VERSION = exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = exports.DEFAULT_CODEX_LOG_TAIL_CHARS = exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
 exports.resolveDescendantProcessIds = resolveDescendantProcessIds;
 exports.readPositiveEnvInt = readPositiveEnvInt;
 exports.readEnvBoolean = readEnvBoolean;
@@ -14,11 +14,9 @@ exports.extractClaudeSessionId = extractClaudeSessionId;
 exports.extractGrokRunMetadata = extractGrokRunMetadata;
 exports.readCodexRolloutTokenUsageForThread = readCodexRolloutTokenUsageForThread;
 exports.extractCodexTokensUsed = extractCodexTokensUsed;
-exports.assertWorkerTokenUsageWithinCap = assertWorkerTokenUsageWithinCap;
 exports.runLoggedProcess = runLoggedProcess;
 exports.buildCodexExecArgs = buildCodexExecArgs;
 exports.buildGrokExecArgs = buildGrokExecArgs;
-exports.readCodexSandboxMode = readCodexSandboxMode;
 exports.buildClaudeExecArgs = buildClaudeExecArgs;
 exports.resolvePlaywrightMcpCliPath = resolvePlaywrightMcpCliPath;
 exports.buildPlaywrightMcpCommand = buildPlaywrightMcpCommand;
@@ -35,10 +33,10 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const surfaceProfiles_1 = require("../../apps/surfaceProfiles");
 const CHILD_KILL_GRACE_MS = 10000;
+const PROVIDER_EXIT_PIPE_CLOSE_GRACE_MS = 1000;
 exports.DEFAULT_CODEX_TIMEOUT_MS = 2 * 60 * 60 * 1000;
 exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = 60 * 60 * 1000;
 exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = 30 * 60 * 1000;
-exports.DEFAULT_WORKER_TOKEN_CAP = 20000000;
 exports.DEFAULT_CODEX_LOG_TAIL_CHARS = 12000;
 exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = 10000;
 function tailText(value, maxChars) {
@@ -412,15 +410,6 @@ async function readCodexRolloutTokenUsageForThread(threadId, options = {}) {
 function extractCodexTokensUsed(output) {
     return extractAgentTokenUsage(output).totalTokens;
 }
-function assertWorkerTokenUsageWithinCap(input) {
-    if (input.tokensUsed === null) {
-        return false;
-    }
-    if (input.tokensUsed > input.tokenCap) {
-        throw new Error(`token_cap_exceeded:${input.tokensUsed}:${input.tokenCap}`);
-    }
-    return true;
-}
 async function runLoggedProcess(input) {
     if (!input.command.trim()) {
         throw new Error("invalid_process_command");
@@ -443,6 +432,7 @@ async function runLoggedProcess(input) {
         let closed = false;
         let killTimer = null;
         let terminateKillTimer = null;
+        let providerExitPipeCloseTimer = null;
         let transcriptFlushTimer = null;
         let transcriptFlushError = null;
         let transcriptFlushPromise = Promise.resolve();
@@ -490,9 +480,9 @@ async function runLoggedProcess(input) {
                 await input.onTranscriptChunks(chunks);
             }
             catch (error) {
-                // Transcript upload is telemetry, never task-critical: requeue in order and retry with the next flush.
+                // Local transcript spooling is telemetry, never task-critical: requeue in order and retry with the next flush.
                 pendingTranscriptChunks.unshift(...chunks);
-                console.error(`warning: transcript chunk upload failed, will retry with next flush: ${error instanceof Error ? error.message : String(error)}`);
+                console.error(`warning: transcript spool write failed, will retry with next flush: ${error instanceof Error ? error.message : String(error)}`);
             }
         };
         const queueTranscriptFlush = () => {
@@ -546,6 +536,20 @@ async function runLoggedProcess(input) {
         child.stdout?.on("data", (chunk) => append("stdout", chunk));
         child.stderr?.on("data", (chunk) => append("stderr", chunk));
         child.on("error", reject);
+        child.on("exit", () => {
+            // Provider CLIs can exit while MCP servers or browsers still inherit their
+            // stdout pipes. Kill the task process group now so `close` is not held
+            // open until the task timeout or lease reaper fires.
+            if (process.platform !== "win32") {
+                terminateProcessTree("SIGKILL");
+            }
+            providerExitPipeCloseTimer = setTimeout(() => {
+                if (closed)
+                    return;
+                child.stdout?.destroy();
+                child.stderr?.destroy();
+            }, PROVIDER_EXIT_PIPE_CLOSE_GRACE_MS);
+        });
         child.on("close", (code, signal) => {
             closed = true;
             // The provider process may leave MCP servers, browsers, dev servers, or recorders behind.
@@ -558,17 +562,20 @@ async function runLoggedProcess(input) {
             if (terminateKillTimer) {
                 clearTimeout(terminateKillTimer);
             }
+            if (providerExitPipeCloseTimer) {
+                clearTimeout(providerExitPipeCloseTimer);
+            }
             if (transcriptFlushTimer) {
                 clearInterval(transcriptFlushTimer);
             }
             void (async () => {
                 await queueTranscriptFlush();
                 if (pendingTranscriptChunks.length > 0) {
-                    // Last flush failed: retry once, then drop with a warning. Missing transcript chunks never fail the task.
+                    // Last spool write failed: retry once, then warn. Transcript telemetry never fails the task.
                     await flushTranscriptChunks();
                 }
                 if (pendingTranscriptChunks.length > 0) {
-                    console.error(`warning: dropped ${pendingTranscriptChunks.length} transcript chunk(s) after final retry; transcript is telemetry, continuing`);
+                    console.error(`warning: could not spool ${pendingTranscriptChunks.length} transcript segment(s) after final retry; transcript is telemetry, continuing`);
                 }
                 if (transcriptFlushError) {
                     throwLoggedProcessError(transcriptFlushError);
@@ -590,13 +597,14 @@ async function runLoggedProcess(input) {
     });
 }
 function buildCodexExecArgs(input) {
-    const sandboxMode = input.sandboxMode ?? "danger-full-access";
     const resumeSessionId = input.resumeSessionId?.trim() ?? "";
     if (resumeSessionId) {
         return [
             "exec",
             "resume",
             "--json",
+            "--dangerously-bypass-approvals-and-sandbox",
+            "--ignore-rules",
             "--skip-git-repo-check",
             "--model",
             input.model,
@@ -609,8 +617,8 @@ function buildCodexExecArgs(input) {
     const args = [
         "exec",
         "--json",
-        "--sandbox",
-        sandboxMode,
+        "--dangerously-bypass-approvals-and-sandbox",
+        "--ignore-rules",
         "--cd",
         input.workspaceDir,
         "--skip-git-repo-check",
@@ -619,9 +627,6 @@ function buildCodexExecArgs(input) {
         "-c",
         `model_reasoning_effort="${input.reasoningEffort}"`,
     ];
-    if (sandboxMode === "workspace-write") {
-        args.push("-c", `sandbox_workspace_write.network_access=${input.networkAccess ? "true" : "false"}`);
-    }
     for (const imagePath of input.imagePaths ?? []) {
         args.push("--image", imagePath);
     }
@@ -653,10 +658,8 @@ function buildGrokExecArgs(input) {
         reasoningEffort,
         "--output-format",
         "streaming-messages-json",
-        "--always-approve",
-        "--sandbox",
-        "devbox",
-        "--no-subagents",
+        "--permission-mode",
+        "bypassPermissions",
         "--no-memory",
         "--no-auto-update",
         "--verbatim",
@@ -667,16 +670,6 @@ function buildGrokExecArgs(input) {
     }
     return args;
 }
-function readCodexSandboxMode(env = process.env) {
-    const raw = env.PLAYDROP_WORKER_CODEX_SANDBOX?.trim();
-    if (!raw) {
-        return "danger-full-access";
-    }
-    if (raw === "danger-full-access" || raw === "workspace-write" || raw === "read-only") {
-        return raw;
-    }
-    throw new Error(`invalid_playdrop_worker_codex_sandbox:${raw}`);
-}
 function buildClaudeExecArgs(input) {
     const model = input.model.trim();
     if (!model) {
@@ -693,8 +686,8 @@ function buildClaudeExecArgs(input) {
         workspaceDir: input.workspaceDir,
         denyReadRoots: input.denyReadRoots ?? [],
         playdropCliEnabled: input.playdropCliEnabled,
+        allowGit: input.allowGit,
     });
-    const permissionMode = input.chrome || input.playwrightMcp ? "bypassPermissions" : "acceptEdits";
     // MCP tools are deferred behind ToolSearch in the Claude CLI; without it in the toolset a
     // session cannot reach any MCP server's tools no matter what --mcp-config provides.
     const tools = input.chrome
@@ -702,7 +695,7 @@ function buildClaudeExecArgs(input) {
         : input.playwrightMcp
             ? [...CLAUDE_BASE_TOOL_NAMES, "ToolSearch"].join(",")
             : CLAUDE_BASE_TOOL_NAMES.join(",");
-    const allowedPermissionRules = buildClaudeAllowedPermissionRules(input.workspaceDir, input.playdropCliEnabled);
+    const allowedPermissionRules = buildClaudeAllowedPermissionRules(input.workspaceDir, input.playdropCliEnabled, input.allowGit === true);
     const allowedTools = input.chrome
         ? [...allowedPermissionRules, ...CLAUDE_CHROME_TOOL_NAMES]
         : input.playwrightMcp
@@ -722,13 +715,13 @@ function buildClaudeExecArgs(input) {
         "--verbose",
         "--include-partial-messages",
         "--permission-mode",
-        permissionMode,
+        "bypassPermissions",
         "--tools",
         tools,
         "--allowedTools",
         ...allowedTools,
         "--disallowedTools",
-        ...buildClaudeDeniedPermissionRules(input.denyReadRoots ?? []),
+        ...buildClaudeDeniedPermissionRules(input.denyReadRoots ?? [], input.allowGit === true),
         "--settings",
         JSON.stringify(permissionSettings),
     ];
@@ -855,7 +848,7 @@ function normalizeClaudePermissionPath(value) {
     }
     return node_path_1.default.resolve(trimmed).replace(/\\/g, "/").replace(/\/+$/, "");
 }
-function buildClaudeAllowedPermissionRules(workspaceDir, playdropCliEnabled = true) {
+function buildClaudeAllowedPermissionRules(workspaceDir, playdropCliEnabled = true, allowGit = false) {
     const workspaceRoot = typeof workspaceDir === "string" && workspaceDir.trim() ? normalizeClaudePermissionPath(workspaceDir) : null;
     if (!workspaceRoot) {
         throw new Error("worker_claude_workspace_missing");
@@ -867,6 +860,7 @@ function buildClaudeAllowedPermissionRules(workspaceDir, playdropCliEnabled = tr
         `Edit(${absoluteWorkspacePattern})`,
         `Write(${absoluteWorkspacePattern})`,
         `Bash(${managedImagePython} *)`,
+        ...(allowGit ? ["Bash(git *)"] : []),
         ...(playdropCliEnabled ? [`Bash(${workspaceRoot}/bin/playdrop *)`] : []),
         ...CLAUDE_BUILD_PERMISSION_RULES.filter((rule) => playdropCliEnabled || !rule.toLowerCase().includes("playdrop")),
     ];
@@ -874,13 +868,13 @@ function buildClaudeAllowedPermissionRules(workspaceDir, playdropCliEnabled = tr
 function buildClaudePermissionSettings(input = {}) {
     return {
         permissions: {
-            allow: buildClaudeAllowedPermissionRules(input.workspaceDir, input.playdropCliEnabled),
-            deny: buildClaudeDeniedPermissionRules(input.denyReadRoots ?? []),
+            allow: buildClaudeAllowedPermissionRules(input.workspaceDir, input.playdropCliEnabled, input.allowGit === true),
+            deny: buildClaudeDeniedPermissionRules(input.denyReadRoots ?? [], input.allowGit === true),
         },
     };
 }
-function buildClaudeDeniedPermissionRules(denyReadRoots = []) {
-    const deny = new Set(["Bash(rm *)", "Bash(git *)"]);
+function buildClaudeDeniedPermissionRules(denyReadRoots = [], allowGit = false) {
+    const deny = new Set(["Bash(rm *)", ...(allowGit ? [] : ["Bash(git *)"])]);
     for (const rawRoot of denyReadRoots) {
         const root = normalizeClaudePermissionPath(rawRoot);
         if (!root) {
@@ -954,8 +948,8 @@ function buildWorkerChildEnv(input) {
     for (const key of [
         "PLAYDROP_API_BASE",
         `PLAYDROP_API_BASE_${input.envName.toUpperCase()}`,
-        "PLAYDROP_AI_BASE",
-        `PLAYDROP_AI_BASE_${input.envName.toUpperCase()}`,
+        "PLAYDROP_WEB_BASE",
+        `PLAYDROP_WEB_BASE_${input.envName.toUpperCase()}`,
     ]) {
         const value = base[key];
         if (typeof value === "string") {
@@ -983,6 +977,17 @@ function buildWorkerChildEnv(input) {
     if (input.eventDir?.trim()) {
         child.PLAYDROP_WORKER_EVENT_DIR = input.eventDir.trim();
     }
+    if (input.gameServerDev) {
+        const redisUrl = input.gameServerDev.redisUrl.trim();
+        const mongoUrl = input.gameServerDev.mongoUrl.trim();
+        const redisNamespace = input.gameServerDev.redisNamespace.trim();
+        if (!redisUrl.startsWith("redis://") || !mongoUrl.startsWith("mongodb://") || !redisNamespace.endsWith(":")) {
+            throw new Error("invalid_worker_game_server_dev_lease");
+        }
+        child.PLAYDROP_DEV_REDIS_URL = redisUrl;
+        child.PLAYDROP_DEV_MONGO_URL = mongoUrl;
+        child.PLAYDROP_DEV_REDIS_NAMESPACE = redisNamespace;
+    }
     return child;
 }
 function buildCleanRoomChildEnv(input) {

package/dist/commands/worker.d.ts

@@ -1,13 +1,14 @@
 import type { ApiClient } from "@playdrop/api-client";
-import { RELEASE_SMOKE_FILE_NAME, type AgentAvailabilityFailureReason, type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AppSurface, type AgentWorkerCapabilities, type AgentWorkerResponse, type AgentWorkerUpdatePolicyResponse, type JsonValue, type WorkerTaskAssignmentV2, type WorkerTaskAssignmentV3, type WorkerTaskPluginV2, type WorkerClaimAgentTaskResponse, type WorkerClaimTaskResponseV3 } from "@playdrop/types";
+import { RELEASE_SMOKE_FILE_NAME, type AgentAvailabilityFailureReason, type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AgentTaskStatus, type AgentTaskTerminalReason, type AppSurface, type AgentWorkerCapabilities, type AgentWorkerResponse, type AgentWorkerUpdatePolicyResponse, type JsonValue, type WorkerGameTaskAssignment, type WorkerTaskPluginV2, type WorkerClaimTaskResponseV5 } from "@playdrop/types";
+import { spawnSync } from "node:child_process";
 import { loadConfig } from "../config";
 import { runShell } from "../shellProbe";
-import { type WorkerInstrumentSurface, type LoggedProcessResult, type LoggedProcessTranscriptChunk } from "./worker/runtime";
+import { type WorkerInstrumentSurface, type LoggedProcessResult } from "./worker/runtime";
 export { extractZipArchive } from "./worker/archive-staging";
-export { assertWorkerTokenUsageWithinCap, buildClaudeExecArgs, buildClaudePermissionSettings, buildCleanRoomChildEnv, buildCodexExecArgs, buildGrokExecArgs, buildPlaywrightMcpCommand, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_CREATOR_AGENT_TIMEOUT_MS, DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractClaudeSessionId, extractCodexThreadId, extractGrokRunMetadata, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readCodexSandboxMode, readEnvBoolean, runLoggedProcess, } from "./worker/runtime";
+export { buildClaudeExecArgs, buildClaudePermissionSettings, buildCleanRoomChildEnv, buildCodexExecArgs, buildGrokExecArgs, buildPlaywrightMcpCommand, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_CREATOR_AGENT_TIMEOUT_MS, DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractClaudeSessionId, extractCodexThreadId, extractGrokRunMetadata, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readEnvBoolean, runLoggedProcess, } from "./worker/runtime";
 export type { AgentTokenUsage, LoggedProcessResult, LoggedProcessTranscriptChunk } from "./worker/runtime";
 export declare const WORKSPACE_ARCHIVE_DOWNLOAD_TIMEOUT_MS: number;
-type WorkerTaskAssignment = WorkerTaskAssignmentV2 | WorkerTaskAssignmentV3;
+type WorkerTaskAssignment = WorkerGameTaskAssignment;
 export declare function usesCreatorRecovery(kind: AgentTaskKind): boolean;
 export declare function buildDeterministicReleaseSmokeArtifact(): {
     fileName: typeof RELEASE_SMOKE_FILE_NAME;
@@ -18,6 +19,15 @@ export declare function buildCreatorRecoveryPrompt(input: {
     prompt: string;
     kind: AgentTaskKind;
 }): string;
+export declare function buildMissingAgentOutcomeRecoveryPrompt(kind: AgentTaskKind): string;
+export declare function shouldRecoverMissingAgentOutcome(input: {
+    kind: AgentTaskKind;
+    taskStatus: AgentTaskStatus;
+    completionReported: boolean;
+    result: Pick<LoggedProcessResult, "exitCode" | "signal" | "timedOut">;
+}): boolean;
+export declare function missingAgentOutcomeTerminalReason(): AgentTaskTerminalReason;
+export declare function creationTimeoutTerminalReason(): AgentTaskTerminalReason;
 export declare function buildGameEvalRetryPrompt(prompt: string): string;
 export declare const WORKER_SESSION_EXPIRED_MESSAGE = "worker session expired: run \"playdrop auth login\" and start the worker again";
 export declare const WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task 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.";
@@ -153,6 +163,7 @@ type WorkerTaskContextFile = {
     taskId: number;
     attempt: number;
     taskToken: string;
+    taskAccessToken: string | null;
     taskType: string;
     metadata: Record<string, JsonValue>;
     kind: AgentTaskKind;
@@ -169,6 +180,23 @@ type WorkerTaskContextFile = {
     reviewAppVersionId?: number | null;
     devPort: number;
     env: string;
+    gameSourceGit: boolean;
+};
+type WorkerTaskUploadResultFile = {
+    taskId: number;
+    appId: number;
+    appVersionId: number;
+    appName: string;
+    version: string;
+    versionNodeId: string;
+    creatorUsername: string;
+};
+type WorkerTaskUploadFailureFile = {
+    schemaVersion: 2;
+    taskId: number;
+    attempt: number;
+    terminalReason: AgentTaskTerminalReason;
+    failedAt: string;
 };
 type WorkerQueuedEvent = {
     kind: "progress" | "catalogue_preview";
@@ -200,9 +228,8 @@ export declare function allocateWorkerDevPort(input: {
 export declare function isWorkerContextCommandAllowed(argv: string[]): boolean;
 export declare function resolveWorkerContextCommandBlockMessage(argv: string[]): string | null;
 export declare function resolveWorkerExecutionTargetFromRole(role: unknown): AgentExecutionTarget;
-export declare function normalizeWorkerTaskAssignmentV2(claim: WorkerClaimAgentTaskResponse): WorkerTaskAssignmentV2 | null;
-export declare function normalizeWorkerTaskAssignmentV3(claim: unknown): WorkerTaskAssignmentV3 | null;
-export declare function normalizeWorkerClaimResponseV3(value: unknown): WorkerClaimTaskResponseV3;
+export declare function normalizeWorkerGameTaskAssignment(value: unknown): WorkerGameTaskAssignment;
+export declare function normalizeWorkerClaimResponseV5(value: unknown): WorkerClaimTaskResponseV5;
 export declare function nextClaimBackoffMs(currentMs: number): number;
 export declare function claimBackoffDelayMs(currentMs: number, random?: () => number): number;
 export declare function acknowledgeWorkerTaskClaim(input: {
@@ -222,6 +249,7 @@ export declare function containWorkerTaskRun(input: {
     logError?: (message: string) => void;
 }): Promise<void>;
 export declare function resolveWorkerHomeDir(): string;
+export declare function configureWorkerFal(): Promise<void>;
 export declare const WORKER_TASK_WORKSPACE_RETENTION = 20;
 export declare function pruneWorkerTaskWorkspaces(incomingWorkspaceDir: string, retention?: number): Promise<string[]>;
 export declare function prepareClaimedTaskWorkspace(input: {
@@ -233,14 +261,19 @@ export declare function prepareClaimedTaskWorkspace(input: {
 export declare function buildWorkerTaskContextV2(assignment: WorkerTaskAssignment): Omit<WorkerTaskContextFile, "env" | "devPort">;
 export declare function resolveWorkerInstrumentSurface(taskContext: Pick<WorkerTaskContextFile, "kind" | "metadata">): WorkerInstrumentSurface | null;
 export declare function hasAgentTaskUploadedArtifact(task: Pick<AgentTaskResponse, "appId" | "appVersionId">): boolean;
-export declare function appendWorkerTranscriptChunks(input: {
-    client: Pick<ApiClient, "workerAppendAgentTaskTranscriptChunks">;
-    taskId: number;
-    workerKey: string;
-    leaseToken: string;
-    chunks: LoggedProcessTranscriptChunk[];
-    batchSize?: number;
-}): Promise<void>;
+export declare function buildWorkerTranscriptUploadHeaders(input: {
+    headers: Record<string, string>;
+    contentType: string;
+    md5Base64: string;
+}): Record<string, string>;
+export declare function describeTaskUploadFailure(error: unknown): AgentTaskTerminalReason;
+export declare function recordTaskUploadFailure(input: {
+    workspaceDir: string;
+    taskContext: Pick<WorkerTaskContextFile, "taskId" | "attempt">;
+    error: unknown;
+}): Promise<WorkerTaskUploadFailureFile>;
+export declare function readTaskUploadFailureFile(startDir?: string): WorkerTaskUploadFailureFile | null;
+export declare function readTaskUploadResultFile(startDir?: string): WorkerTaskUploadResultFile;
 export declare function readTaskNextStepsFile(filePath: string | undefined, workspaceDir?: string): AgentTaskNextStepSuggestion[] | undefined;
 export declare function assertTaskUploadResultMatchesContext(input: {
     taskContext: {
@@ -256,8 +289,7 @@ export declare function assertTaskUploadResultMatchesContext(input: {
         creatorUsername: string;
     };
 }): void;
-export declare function stageAssignmentWorkspaceV2(workspaceDir: string, workspace: WorkerTaskAssignmentV2["workspace"]): Promise<void>;
-export declare function stageAssignmentWorkspaceV3(workspaceDir: string, workspace: WorkerTaskAssignmentV3["workspace"], options?: {
+export declare function stageAssignmentWorkspace(workspaceDir: string, workspace: WorkerGameTaskAssignment["workspace"], options?: {
     timeoutMs?: number;
 }): Promise<void>;
 export declare function assertAssignmentPluginBundleExtractionBounds(buffer: Buffer): void;
@@ -303,6 +335,11 @@ export declare function buildWorkerCapabilities(input: {
         version?: string;
         chromiumInstalled?: boolean;
     } | null;
+    codexImageGenerationAvailable?: boolean | null;
+    falConfigured?: boolean | null;
+    falAuthenticated?: boolean | null;
+    ffmpegReady?: boolean | null;
+    requireGenerationRuntime?: boolean;
     maxParallelTasks?: number | null;
     runningTaskCount?: number | null;
 }): AgentWorkerCapabilities;
@@ -311,7 +348,7 @@ export declare function buildWorkerClaimBody(input: {
     capabilities: AgentWorkerCapabilities;
     runningTaskCount?: number;
 }): {
-    protocolVersion: 3;
+    protocolVersion: 5;
     workerKey: string;
     capabilities: AgentWorkerCapabilities;
 };
@@ -326,6 +363,7 @@ export declare function prepareCodexRunHomes(input: {
     envName: string;
     sourceCodexHome?: string;
     playdropConfig?: ReturnType<typeof loadConfig>;
+    playdropAccessToken?: string | null;
     stagePlaydropSession?: boolean;
     preserveExisting?: boolean;
 }): Promise<{
@@ -337,6 +375,7 @@ export declare function prepareClaudeRunConfig(input: {
     workerUsername: string;
     envName: string;
     playdropConfig?: ReturnType<typeof loadConfig>;
+    playdropAccessToken?: string | null;
 }): Promise<{
     playdropConfigPath: string;
 }>;
@@ -345,6 +384,7 @@ export declare function prepareGrokRunConfig(input: {
     workerUsername: string;
     envName: string;
     playdropConfig?: ReturnType<typeof loadConfig>;
+    playdropAccessToken?: string | null;
     preserveExisting?: boolean;
     stagePlaydropSession?: boolean;
 }): Promise<{
@@ -371,24 +411,35 @@ export declare function buildGrokPromptJson(input: {
 export declare function buildGrokIsolationEnv(): Record<string, string>;
 export declare function resolveHostGrokAuthPath(homeDir?: string): string;
 export declare function mergeCreatorRecoveryResults(runtime: AgentRuntime, initial: LoggedProcessResult, recovery: LoggedProcessResult): LoggedProcessResult;
+export declare function mergeMissingAgentOutcomeRecoveryResults(runtime: AgentRuntime, initial: LoggedProcessResult, recovery: LoggedProcessResult): LoggedProcessResult;
 export declare function buildAgentFailureCode(agent: AgentRuntime, result: LoggedProcessResult, request?: {
     model: string;
     reasoningEffort?: string | null;
 }): string;
-export declare function classifyAgentAvailabilityFailureReason(errorCode: string): AgentAvailabilityFailureReason | null;
+export declare function classifyAgentAvailabilityFailureReason(errorCode: string, retryTransientProviderFailure?: boolean): AgentAvailabilityFailureReason | null;
 export declare function describeAgentFailureForEvent(errorCode: string): string;
+export declare function normalizeWorkerFailureErrorCode(message: string): string;
 export declare function createLocalPlaydropShim(input: {
     workspaceDir: string;
     taskId: number;
     attempt: number;
     devPort: number;
+    gameSourceGit?: boolean;
 }): Promise<string>;
 export declare function parseCodexModelCatalog(output: string): string[];
+export declare function codexFeatureEnabled(output: string, feature: string): boolean;
 export declare function parseClaudeModelCatalog(output: string): string[];
 export declare function claudeModelProbeReportsSelection(output: string, expectedDisplayName: string): boolean;
 export declare function parseGrokModelCatalog(output: string): string[];
 export declare function probeWorkerProviderIndependently<T>(probe: () => T, unavailable: T): T;
 export declare function describeWorkerPreflightReason(reason: string): string;
+export declare function falAuthenticationProbeExitCode(status: number): 0 | 2 | 3;
+export declare function probeFalAuthentication(workerHomeDir?: string, deps?: {
+    spawnSync: typeof spawnSync;
+}): {
+    authenticated: boolean;
+    error: string | null;
+};
 export declare function buildWorkerSetupActions(input: {
     degradedReasons: string[];
     playwright?: {
@@ -465,6 +516,15 @@ export declare function launchManagedWorker(label: string, plistPath: string, op
 }): void;
 export declare function showWorkerStatus(options?: WorkerStatusOptions): Promise<WorkerStatusPayload>;
 export declare function setupWorker(options?: WorkerSetupOptions): Promise<void>;
+export declare function completeWorkerAgentTaskWithRetry(input: {
+    client: Pick<ApiClient, "workerCompleteAgentTask">;
+    taskId: number;
+    body: Parameters<ApiClient["workerCompleteAgentTask"]>[1];
+    sleepImpl?: (ms: number) => Promise<void>;
+    maxAttempts?: number;
+}): Promise<Awaited<ReturnType<ApiClient["workerCompleteAgentTask"]>>>;
+type WorkerFailureStage = "setup" | "agent" | "post_agent_detail" | "game_source_reconcile" | "game_publish" | "task_complete";
+export declare function classifyWorkerSupervisorFailure(message: string, stage?: WorkerFailureStage): AgentTaskTerminalReason;
 export declare function assignmentRequiresRegisteredBundle(assignment: WorkerTaskAssignment): boolean;
 export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
 export declare function reportTask(options: TaskReportOptions): Promise<void>;