@playdrop/playdrop-cli 0.9.6 → 0.10.1

package/dist/commands/worker.js

@@ -0,0 +1,2626 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = exports.WORKER_SESSION_EXPIRED_MESSAGE = exports.runLoggedProcess = exports.readCodexSandboxMode = exports.readEnvBoolean = exports.extractCodexTokensUsed = exports.extractAgentTokenUsage = exports.buildWorkerChildEnv = exports.buildClaudePermissionSettings = exports.buildClaudeExecArgs = exports.buildCodexExecArgs = exports.assertWorkerTokenUsageWithinCap = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
+exports.allocateWorkerDevPort = allocateWorkerDevPort;
+exports.isWorkerContextCommandAllowed = isWorkerContextCommandAllowed;
+exports.resolveWorkerExecutionTargetFromRole = resolveWorkerExecutionTargetFromRole;
+exports.resolveWorkerClaimTaskAssignment = resolveWorkerClaimTaskAssignment;
+exports.nextClaimBackoffMs = nextClaimBackoffMs;
+exports.claimBackoffDelayMs = claimBackoffDelayMs;
+exports.resolveWorkerHomeDir = resolveWorkerHomeDir;
+exports.hasAgentTaskUploadedArtifact = hasAgentTaskUploadedArtifact;
+exports.appendWorkerTranscriptChunks = appendWorkerTranscriptChunks;
+exports.assertTaskUploadResultMatchesContext = assertTaskUploadResultMatchesContext;
+exports.stageAssignmentWorkspaceFiles = stageAssignmentWorkspaceFiles;
+exports.resolvePlaydropPluginRoot = resolvePlaydropPluginRoot;
+exports.stagePlaydropPluginReferences = stagePlaydropPluginReferences;
+exports.discoverWorkerProjectRoot = discoverWorkerProjectRoot;
+exports.readWorkerTaskState = readWorkerTaskState;
+exports.buildWorkerHealthAlertText = buildWorkerHealthAlertText;
+exports.isWorkerAuthFailureError = isWorkerAuthFailureError;
+exports.classifyWorkerEventDrainError = classifyWorkerEventDrainError;
+exports.assertWorkerClaimErrorRetryable = assertWorkerClaimErrorRetryable;
+exports.resolvePlaydropAssetRequirementFromText = resolvePlaydropAssetRequirementFromText;
+exports.loadWorkerEnvFile = loadWorkerEnvFile;
+exports.buildWorkerCapabilities = buildWorkerCapabilities;
+exports.buildWorkerClaimBody = buildWorkerClaimBody;
+exports.resolveWorkerBaseSource = resolveWorkerBaseSource;
+exports.extractZipArchive = extractZipArchive;
+exports.readWorkerProjectVersion = readWorkerProjectVersion;
+exports.buildCataloguePreviewPayload = buildCataloguePreviewPayload;
+exports.assertWorkerProjectVersionBumped = assertWorkerProjectVersionBumped;
+exports.buildAgentFailureCode = buildAgentFailureCode;
+exports.describeAgentFailureForEvent = describeAgentFailureForEvent;
+exports.startWorker = startWorker;
+exports.reportTask = reportTask;
+exports.reportCatalogueTask = reportCatalogueTask;
+exports.uploadTask = uploadTask;
+exports.completeTask = completeTask;
+exports.readReviewEvidenceFiles = readReviewEvidenceFiles;
+exports.submitReviewTask = submitReviewTask;
+exports.failTask = failTask;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const node_module_1 = require("node:module");
+const fflate_1 = require("fflate");
+const types_1 = require("@playdrop/types");
+const commandContext_1 = require("../commandContext");
+const config_1 = require("../config");
+const clientInfo_1 = require("../clientInfo");
+const messages_1 = require("../messages");
+const output_1 = require("../output");
+const shellProbe_1 = require("../shellProbe");
+const upload_1 = require("./upload");
+const review_1 = require("./review");
+const runtime_1 = require("./worker/runtime");
+var runtime_2 = require("./worker/runtime");
+Object.defineProperty(exports, "DEFAULT_CODEX_TIMEOUT_MS", { enumerable: true, get: function () { return runtime_2.DEFAULT_CODEX_TIMEOUT_MS; } });
+Object.defineProperty(exports, "DEFAULT_WORKER_TOKEN_CAP", { enumerable: true, get: function () { return runtime_2.DEFAULT_WORKER_TOKEN_CAP; } });
+Object.defineProperty(exports, "assertWorkerTokenUsageWithinCap", { enumerable: true, get: function () { return runtime_2.assertWorkerTokenUsageWithinCap; } });
+Object.defineProperty(exports, "buildCodexExecArgs", { enumerable: true, get: function () { return runtime_2.buildCodexExecArgs; } });
+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, "buildWorkerChildEnv", { enumerable: true, get: function () { return runtime_2.buildWorkerChildEnv; } });
+Object.defineProperty(exports, "extractAgentTokenUsage", { enumerable: true, get: function () { return runtime_2.extractAgentTokenUsage; } });
+Object.defineProperty(exports, "extractCodexTokensUsed", { enumerable: true, get: function () { return runtime_2.extractCodexTokensUsed; } });
+Object.defineProperty(exports, "readEnvBoolean", { enumerable: true, get: function () { return runtime_2.readEnvBoolean; } });
+Object.defineProperty(exports, "readCodexSandboxMode", { enumerable: true, get: function () { return runtime_2.readCodexSandboxMode; } });
+Object.defineProperty(exports, "runLoggedProcess", { enumerable: true, get: function () { return runtime_2.runLoggedProcess; } });
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const HEARTBEAT_INTERVAL_MS = 10000;
+const DEFAULT_WORKER_MAX_PARALLEL_TASKS = 5;
+const DEFAULT_WORKER_DEV_PORT_BASE = 8900;
+const CLAIM_BACKOFF_BASE_MS = 1000;
+const CLAIM_BACKOFF_MAX_MS = 60000;
+const CLAIM_BACKOFF_JITTER_MS = 500;
+const FAIL_REPORT_RETRY_DELAY_MS = 2000;
+const WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE = 100;
+const SLACK_API_BASE_URL = 'https://slack.com/api';
+const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'GAME_UPDATE', 'GAME_REVIEW'];
+const requireFromWorker = (0, node_module_1.createRequire)(__filename);
+const PLAYDROP_PLUGIN_DAEMON_GAME_CREATION_SKILL_PATH = 'skills/daemon-game-creation/SKILL.md';
+const PLAYDROP_PLUGIN_GAME_IMPROVEMENT_SKILL_PATH = 'skills/game-improvement/SKILL.md';
+const PLAYDROP_PLUGIN_ASSET_DISCOVERY_SKILL_PATH = 'skills/asset-discovery/SKILL.md';
+const PLAYDROP_PLUGIN_ASSET_EXTRACTION_SKILL_PATH = 'skills/asset-extraction-2d/SKILL.md';
+const PLAYDROP_PLUGIN_LISTING_ART_SKILL_PATH = 'skills/listing-art/SKILL.md';
+const PLAYDROP_PLUGIN_GAME_REVIEW_SKILL_PATH = 'skills/game-review/SKILL.md';
+const PLAYDROP_PLUGIN_ASSET_REUSE_REFERENCE_PATH = 'references/asset-reuse.md';
+const PLAYDROP_PLUGIN_ASSETS_AND_GENERATION_REFERENCE_PATH = 'references/assets-and-generation.md';
+const PLAYDROP_PLUGIN_CODE_REUSE_REFERENCE_PATH = 'references/code-reuse.md';
+const PLAYDROP_PLUGIN_EXTRACTOR_PATH = 'scripts/extract-alpha-background-swap.ts';
+const PLAYDROP_PLUGIN_LISTING_ICON_SCRIPT_PATH = 'scripts/compose-listing-icon.ts';
+const PLAYDROP_PLUGIN_LISTING_TITLE_SCRIPT_PATH = 'scripts/compose-listing-title.ts';
+const STAGED_PLAYDROP_PLUGIN_ROOT = '.playdrop/plugin';
+const PLAYDROP_PLUGIN_CREATION_REFERENCE_FILES = [
+    PLAYDROP_PLUGIN_DAEMON_GAME_CREATION_SKILL_PATH,
+    PLAYDROP_PLUGIN_GAME_IMPROVEMENT_SKILL_PATH,
+    PLAYDROP_PLUGIN_ASSET_DISCOVERY_SKILL_PATH,
+    PLAYDROP_PLUGIN_ASSET_EXTRACTION_SKILL_PATH,
+    PLAYDROP_PLUGIN_LISTING_ART_SKILL_PATH,
+    PLAYDROP_PLUGIN_ASSET_REUSE_REFERENCE_PATH,
+    PLAYDROP_PLUGIN_ASSETS_AND_GENERATION_REFERENCE_PATH,
+    PLAYDROP_PLUGIN_CODE_REUSE_REFERENCE_PATH,
+    PLAYDROP_PLUGIN_EXTRACTOR_PATH,
+    PLAYDROP_PLUGIN_LISTING_ICON_SCRIPT_PATH,
+    PLAYDROP_PLUGIN_LISTING_TITLE_SCRIPT_PATH,
+];
+const PLAYDROP_PLUGIN_GAME_REVIEW_REFERENCE_FILES = [
+    PLAYDROP_PLUGIN_GAME_REVIEW_SKILL_PATH,
+    'references/game-review-criteria.md',
+    'references/game-review-comparative-method.md',
+    'references/game-review-evidence-capture.md',
+    'references/game-review-rating-scale.md',
+    'references/game-review-score-caps.md',
+    'references/game-review-gates.md',
+    'references/game-review-gates/concept.md',
+    'references/game-review-gates/gameplay-prototype.md',
+    'references/game-review-gates/demo.md',
+    'references/game-review-gates/vertical-slice.md',
+    'references/game-review-gates/first-release.md',
+    'references/game-review-gates/mature-live-version.md',
+    'references/game-review-outcomes.md',
+    'references/game-review-feedback-format.md',
+    'references/game-review-dimensions/gameplay-core-loop.md',
+    'references/game-review-dimensions/depth-replayability.md',
+    'references/game-review-dimensions/controls-input.md',
+    'references/game-review-dimensions/ux-usability.md',
+    'references/game-review-dimensions/first-time-user-experience.md',
+    'references/game-review-dimensions/visuals-art-direction.md',
+    'references/game-review-dimensions/audio-feedback.md',
+    'references/game-review-dimensions/store-listing-metadata-accuracy.md',
+    'references/game-review-dimensions/safety-age-rating-compliance.md',
+    'references/game-review-dimensions/performance-stability.md',
+];
+const PLAYDROP_PLUGIN_REFERENCE_FILES = [
+    ...PLAYDROP_PLUGIN_CREATION_REFERENCE_FILES,
+    ...PLAYDROP_PLUGIN_GAME_REVIEW_REFERENCE_FILES,
+];
+exports.WORKER_SESSION_EXPIRED_MESSAGE = 'worker session expired: run "playdrop auth login" and start the worker again';
+const WORKER_CONTEXT_ALLOWED_COMMANDS = [
+    ['task', 'report'],
+    ['task', 'report-catalogue'],
+    ['task', 'upload'],
+    ['task', 'done'],
+    ['task', 'submit-review'],
+    ['task', 'fail'],
+    ['review', 'validate-result'],
+    ['review', 'compose-evidence'],
+    ['review', 'rating-card'],
+    ['project', 'validate'],
+    ['project', 'build'],
+    ['project', 'dev'],
+    ['project', 'capture'],
+    ['browse'],
+    ['search'],
+    ['detail'],
+    ['versions', 'browse'],
+    ['documentation', 'browse'],
+    ['documentation', 'read'],
+    ['ai', 'create'],
+    ['ai', 'jobs', 'browse'],
+    ['ai', 'jobs', 'detail'],
+    ['ai', 'generations'],
+];
+exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = 'worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task upload/done/fail, project validation/build/dev/capture, read-only catalogue/documentation lookup, and PlayDrop AI generation are permitted.';
+function allocateWorkerDevPort(input) {
+    const basePort = input.basePort ?? DEFAULT_WORKER_DEV_PORT_BASE;
+    const maxParallelTasks = input.maxParallelTasks ?? DEFAULT_WORKER_MAX_PARALLEL_TASKS;
+    if (!Number.isInteger(basePort) || basePort <= 0 || basePort > 65535) {
+        throw new Error('invalid_worker_dev_port_base');
+    }
+    if (!Number.isInteger(maxParallelTasks) || maxParallelTasks <= 0) {
+        throw new Error('invalid_worker_max_parallel_tasks');
+    }
+    for (let offset = 0; offset < maxParallelTasks; offset += 1) {
+        const port = basePort + offset;
+        if (port > 65535) {
+            throw new Error('worker_dev_port_range_exhausted');
+        }
+        if (!input.activePorts.has(port)) {
+            return port;
+        }
+    }
+    throw new Error('worker_dev_port_pool_exhausted');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isWorkerContextCommandAllowed(argv) {
+    return WORKER_CONTEXT_ALLOWED_COMMANDS.some((allowed) => allowed.every((part, index) => argv[index] === part));
+}
+function resolveWorkerExecutionTargetFromRole(role) {
+    return role === 'ADMIN' ? 'FIRST_PARTY' : 'PERSONAL';
+}
+function normalizeAssignmentWorkspaceFolder(value) {
+    const folderName = typeof value === 'string' ? value.trim() : '';
+    if (!folderName) {
+        throw new Error('agent_task_assignment_workspace_missing');
+    }
+    if (!/^[a-zA-Z0-9._-]+$/.test(folderName) || folderName === '.' || folderName === '..') {
+        throw new Error('agent_task_assignment_workspace_unsafe');
+    }
+    return folderName;
+}
+function normalizeAssignmentAgent(value) {
+    if (value !== 'CODEX' && value !== 'CLAUDE_CODE') {
+        throw new Error('agent_task_assignment_agent_missing');
+    }
+    return value;
+}
+function normalizeAssignmentKind(value, task) {
+    if (value !== 'NEW_GAME' && value !== 'GAME_UPDATE' && value !== 'GAME_REVIEW') {
+        throw new Error('agent_task_assignment_kind_missing');
+    }
+    if (value !== task.kind) {
+        throw new Error('agent_task_assignment_kind_mismatch');
+    }
+    return value;
+}
+function normalizeAssignmentTarget(value) {
+    if (value !== 'FIRST_PARTY' && value !== 'PERSONAL') {
+        throw new Error('agent_task_assignment_target_missing');
+    }
+    return value;
+}
+function resolveWorkerClaimTaskAssignment(claim) {
+    if (!claim.task) {
+        return null;
+    }
+    const assignment = claim.taskAssignment;
+    if (!assignment || typeof assignment !== 'object') {
+        throw new Error('agent_task_claim_missing_task_assignment');
+    }
+    const prompt = typeof assignment.prompt === 'string' ? assignment.prompt.trim() : '';
+    if (!prompt) {
+        throw new Error('agent_task_assignment_prompt_missing');
+    }
+    const taskId = parsePositiveInteger(assignment.taskId, 'agent_task_assignment_task_id_missing');
+    if (taskId !== claim.task.id) {
+        throw new Error('agent_task_assignment_task_id_mismatch');
+    }
+    const taskToken = typeof assignment.taskToken === 'string' ? assignment.taskToken.trim() : '';
+    if (!taskToken) {
+        throw new Error('agent_task_assignment_token_missing');
+    }
+    const model = typeof assignment.model === 'string' ? assignment.model.trim() : '';
+    if (!model) {
+        throw new Error('agent_task_assignment_model_missing');
+    }
+    const workspace = assignment.workspace && typeof assignment.workspace === 'object' && !Array.isArray(assignment.workspace)
+        ? assignment.workspace
+        : null;
+    if (!workspace) {
+        throw new Error('agent_task_assignment_workspace_missing');
+    }
+    const inputs = assignment.inputs && typeof assignment.inputs === 'object' && !Array.isArray(assignment.inputs)
+        ? assignment.inputs
+        : null;
+    if (!inputs) {
+        throw new Error('agent_task_assignment_inputs_missing');
+    }
+    const output = assignment.output && typeof assignment.output === 'object' && !Array.isArray(assignment.output)
+        ? assignment.output
+        : null;
+    if (!output) {
+        throw new Error('agent_task_assignment_output_missing');
+    }
+    const version = typeof output.version === 'string' ? output.version.trim() : '';
+    if (!version) {
+        throw new Error('agent_task_assignment_output_version_missing');
+    }
+    return {
+        taskId,
+        taskToken,
+        kind: normalizeAssignmentKind(assignment.kind, claim.task),
+        target: normalizeAssignmentTarget(assignment.target),
+        agent: normalizeAssignmentAgent(assignment.agent),
+        model,
+        workspace: {
+            folderName: normalizeAssignmentWorkspaceFolder(workspace.folderName),
+            files: normalizeAssignmentWorkspaceFiles(workspace.files),
+        },
+        inputs: {
+            request: {
+                prompt: normalizeAssignmentRequest(inputs.request),
+            },
+            attachments: Array.isArray(inputs.attachments) ? inputs.attachments : [],
+            baseSource: inputs.baseSource ?? null,
+            reviewTarget: inputs.reviewTarget ?? null,
+        },
+        output: {
+            appId: typeof output.appId === 'number' && Number.isInteger(output.appId) && output.appId > 0 ? output.appId : null,
+            appName: typeof output.appName === 'string' && output.appName.trim() ? output.appName.trim() : null,
+            version,
+            releaseNoteRequired: output.releaseNoteRequired !== false,
+        },
+        prompt,
+    };
+}
+function nextClaimBackoffMs(currentMs) {
+    return Math.min(Math.max(currentMs, CLAIM_BACKOFF_BASE_MS) * 2, CLAIM_BACKOFF_MAX_MS);
+}
+function claimBackoffDelayMs(currentMs, random = Math.random) {
+    return currentMs + Math.floor(random() * CLAIM_BACKOFF_JITTER_MS);
+}
+function resolveWorkerHomeDir() {
+    const custom = node_process_1.default.env.PLAYDROP_WORKER_HOME?.trim();
+    if (custom) {
+        return custom;
+    }
+    return node_path_1.default.join(node_os_1.default.homedir(), 'PlayDropWorker');
+}
+function workerStateFilePath() {
+    return node_path_1.default.join(resolveWorkerHomeDir(), 'state', 'current-task.json');
+}
+function workerTaskWorkspaceDirFromAssignment(assignment) {
+    return node_path_1.default.join(resolveWorkerHomeDir(), 'tasks', assignment.workspace.folderName);
+}
+function buildWorkerTaskContext(claim, assignment) {
+    const task = claim.task;
+    if (!task) {
+        throw new Error('agent_task_claim_missing_task');
+    }
+    if (task.id !== assignment.taskId) {
+        throw new Error('agent_task_context_task_id_mismatch');
+    }
+    if (task.kind !== assignment.kind) {
+        throw new Error('agent_task_context_kind_mismatch');
+    }
+    if (task.executionTarget !== assignment.target) {
+        throw new Error('agent_task_context_target_mismatch');
+    }
+    const creatorUsername = typeof task.creatorUsername === 'string' ? task.creatorUsername.trim() : '';
+    const outputVersion = typeof assignment.output.version === 'string' ? assignment.output.version.trim() : '';
+    if (!creatorUsername || !outputVersion) {
+        throw new Error('agent_task_context_invalid');
+    }
+    const taskToken = typeof assignment.taskToken === 'string' ? assignment.taskToken.trim() : '';
+    if (!taskToken) {
+        throw new Error('agent_task_context_token_missing');
+    }
+    const attempt = Number(task.attempts);
+    if (!Number.isInteger(attempt) || attempt <= 0) {
+        throw new Error('agent_task_context_attempt_missing');
+    }
+    const outputAppName = typeof assignment.output.appName === 'string' && assignment.output.appName.trim()
+        ? assignment.output.appName.trim()
+        : null;
+    const reviewTarget = assignment.inputs.reviewTarget && typeof assignment.inputs.reviewTarget === 'object'
+        ? assignment.inputs.reviewTarget
+        : null;
+    let reviewAppVersionId = null;
+    if (assignment.kind === 'GAME_REVIEW') {
+        const parsedReviewAppVersionId = Number(reviewTarget?.appVersionId);
+        if (!Number.isInteger(parsedReviewAppVersionId) || parsedReviewAppVersionId <= 0) {
+            throw new Error('agent_task_context_review_target_missing');
+        }
+        reviewAppVersionId = parsedReviewAppVersionId;
+    }
+    const creatorRequest = assignment.inputs.request.prompt.trim();
+    if (!creatorRequest) {
+        throw new Error('agent_task_context_creator_request_missing');
+    }
+    return {
+        taskId: task.id,
+        attempt,
+        taskToken,
+        kind: assignment.kind,
+        creatorUsername,
+        creatorRequest,
+        target: assignment.target,
+        outputAppName,
+        outputVersion,
+        reviewAppVersionId,
+    };
+}
+function workerTaskContextPath(workspaceDir) {
+    return node_path_1.default.join(workspaceDir, '.playdrop', 'task.json');
+}
+function workerTaskUploadResultPath(workspaceDir) {
+    return node_path_1.default.join(workspaceDir, '.playdrop', 'task-upload-result.json');
+}
+async function stageWorkerTaskContext(input) {
+    const playdropDir = node_path_1.default.join(input.workspaceDir, '.playdrop');
+    await (0, promises_1.mkdir)(playdropDir, { recursive: true });
+    const taskFile = {
+        ...input.taskContext,
+        devPort: input.devPort,
+        env: input.env,
+    };
+    await (0, promises_1.writeFile)(workerTaskContextPath(input.workspaceDir), JSON.stringify(taskFile, null, 2), 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(input.workspaceDir, '.playdrop.json'), JSON.stringify({
+        ownerUsername: input.taskContext.creatorUsername,
+        env: input.env,
+        taskId: input.taskContext.taskId,
+        taskAttempt: input.taskContext.attempt,
+        devPort: input.devPort,
+        taskToken: input.taskContext.taskToken,
+    }, null, 2), 'utf8');
+}
+function findWorkspaceTaskFile(startDir, basename) {
+    let current = node_path_1.default.resolve(startDir);
+    while (true) {
+        const candidate = node_path_1.default.join(current, '.playdrop', basename);
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current) {
+            throw new Error(`task_context_missing:${basename}`);
+        }
+        current = parent;
+    }
+}
+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'));
+    const taskId = Number(parsed.taskId);
+    const attempt = Number(parsed.attempt);
+    const taskToken = typeof parsed.taskToken === 'string' ? parsed.taskToken.trim() : '';
+    const creatorUsername = typeof parsed.creatorUsername === 'string' ? parsed.creatorUsername.trim() : '';
+    const env = typeof parsed.env === 'string' ? parsed.env.trim() : '';
+    const creatorRequest = typeof parsed.creatorRequest === 'string' ? parsed.creatorRequest.trim() : '';
+    const outputVersion = typeof parsed.outputVersion === 'string' ? parsed.outputVersion.trim() : '';
+    let reviewAppVersionId = null;
+    if (parsed.reviewAppVersionId !== null && parsed.reviewAppVersionId !== undefined) {
+        const parsedReviewAppVersionId = Number(parsed.reviewAppVersionId);
+        if (Number.isInteger(parsedReviewAppVersionId) && parsedReviewAppVersionId > 0) {
+            reviewAppVersionId = parsedReviewAppVersionId;
+        }
+    }
+    const devPort = typeof parsed.devPort === 'number' ? parsed.devPort : Number.parseInt(String(parsed.devPort ?? ''), 10);
+    if (!Number.isInteger(taskId) || taskId <= 0
+        || !Number.isInteger(attempt) || attempt <= 0
+        || !taskToken
+        || (parsed.kind !== 'NEW_GAME' && parsed.kind !== 'GAME_UPDATE' && parsed.kind !== 'GAME_REVIEW')
+        || (parsed.target !== 'FIRST_PARTY' && parsed.target !== 'PERSONAL')
+        || !creatorUsername
+        || !creatorRequest
+        || !env
+        || !outputVersion
+        || (parsed.kind === 'GAME_REVIEW' && reviewAppVersionId === null)
+        || !Number.isInteger(devPort) || devPort <= 0 || devPort > 65535) {
+        throw new Error(`task_context_invalid:${file}`);
+    }
+    return {
+        taskId,
+        attempt,
+        taskToken,
+        kind: parsed.kind,
+        creatorUsername,
+        creatorRequest,
+        target: parsed.target,
+        outputAppName: typeof parsed.outputAppName === 'string' && parsed.outputAppName.trim() ? parsed.outputAppName.trim() : null,
+        outputVersion,
+        reviewAppVersionId,
+        devPort,
+        env,
+    };
+}
+function normalizeAssignmentRequest(value) {
+    const request = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+    const prompt = typeof request?.prompt === 'string' ? request.prompt.trim() : '';
+    if (!prompt) {
+        throw new Error('agent_task_assignment_request_prompt_missing');
+    }
+    return prompt;
+}
+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, {
+            workerKey: input.workerKey,
+            leaseToken: input.leaseToken,
+            chunks: input.chunks.slice(index, index + batchSize),
+        });
+    }
+}
+function resolvePlaydropAssetRequirementFromTaskRequest(value) {
+    const text = typeof value === 'string' ? value.toLowerCase() : '';
+    if (!text.trim()) {
+        return null;
+    }
+    const mentionsPlaydrop = /\bplay\s*drop\b|\bplaydrop\b/.test(text);
+    if (!mentionsPlaydrop) {
+        return null;
+    }
+    if (/\basset\s*pack(s)?\b|\bpack(s)?\b/.test(text)) {
+        return 'PACK';
+    }
+    if (/\basset(s)?\b|\bsprite(s)?\b|\bmodel(s)?\b|\bart\b|\bcharacter(s)?\b|\bprop(s)?\b/.test(text)) {
+        return 'ASSET_OR_PACK';
+    }
+    return null;
+}
+function resolveTaskWorkspaceDir(startDir = node_process_1.default.cwd()) {
+    return node_path_1.default.dirname(node_path_1.default.dirname(findWorkspaceTaskFile(startDir, 'task.json')));
+}
+function readTaskUploadResultFile(startDir = node_process_1.default.cwd()) {
+    const file = findWorkspaceTaskFile(startDir, '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);
+    const appVersionId = Number(parsed.appVersionId);
+    const appName = typeof parsed.appName === 'string' ? parsed.appName.trim() : '';
+    const version = typeof parsed.version === 'string' ? parsed.version.trim() : '';
+    const versionNodeId = typeof parsed.versionNodeId === 'string' ? parsed.versionNodeId.trim() : '';
+    const creatorUsername = typeof parsed.creatorUsername === 'string' ? parsed.creatorUsername.trim() : '';
+    if (!Number.isInteger(taskId) || taskId <= 0
+        || !Number.isInteger(appId) || appId <= 0
+        || !Number.isInteger(appVersionId) || appVersionId <= 0
+        || !appName
+        || !version
+        || !versionNodeId
+        || !creatorUsername) {
+        throw new Error(`task_upload_result_invalid:${file}`);
+    }
+    return { taskId, appId, appVersionId, appName, version, versionNodeId, creatorUsername };
+}
+function assertTaskUploadResultMatchesContext(input) {
+    if (input.uploadResult.taskId !== input.taskContext.taskId) {
+        throw new Error('task_upload_result_task_mismatch');
+    }
+    if (input.uploadResult.creatorUsername !== input.taskContext.creatorUsername) {
+        throw new Error('task_upload_result_creator_mismatch');
+    }
+    if (input.uploadResult.version !== input.taskContext.outputVersion) {
+        throw new Error('task_upload_result_version_mismatch');
+    }
+    const expectedAppName = typeof input.taskContext.outputAppName === 'string'
+        ? input.taskContext.outputAppName.trim()
+        : '';
+    if (expectedAppName && input.uploadResult.appName !== expectedAppName) {
+        throw new Error('task_upload_result_app_mismatch');
+    }
+}
+function normalizeAssignmentWorkspaceRelativePath(value) {
+    if (typeof value !== 'string') {
+        throw new Error('agent_task_assignment_workspace_file_path_invalid');
+    }
+    const normalizedInput = value.trim().replace(/\\/g, '/');
+    if (!normalizedInput || normalizedInput.includes('\0') || normalizedInput.startsWith('/')) {
+        throw new Error('agent_task_assignment_workspace_file_path_invalid');
+    }
+    const normalizedPath = node_path_1.default.posix.normalize(normalizedInput);
+    if (!normalizedPath
+        || normalizedPath === '.'
+        || normalizedPath === '..'
+        || normalizedPath.startsWith('../')) {
+        throw new Error('agent_task_assignment_workspace_file_path_invalid');
+    }
+    return normalizedPath;
+}
+function normalizeAssignmentWorkspaceFile(value) {
+    const file = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+    if (!file) {
+        throw new Error('agent_task_assignment_workspace_file_invalid');
+    }
+    const relativePath = normalizeAssignmentWorkspaceRelativePath(file.relativePath);
+    const contentBase64 = typeof file.contentBase64 === 'string' ? file.contentBase64.trim() : '';
+    if (!contentBase64 || contentBase64.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(contentBase64)) {
+        throw new Error('agent_task_assignment_workspace_file_content_invalid');
+    }
+    const contentType = typeof file.contentType === 'string' && file.contentType.trim()
+        ? file.contentType.trim()
+        : undefined;
+    return {
+        relativePath,
+        contentBase64,
+        ...(contentType ? { contentType } : {}),
+    };
+}
+function normalizeAssignmentWorkspaceFiles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const seen = new Set();
+    return value.map((entry) => {
+        const normalized = normalizeAssignmentWorkspaceFile(entry);
+        if (seen.has(normalized.relativePath)) {
+            throw new Error('agent_task_assignment_workspace_file_duplicate');
+        }
+        seen.add(normalized.relativePath);
+        return normalized;
+    });
+}
+function resolveWorkspaceFileDestination(workspaceDir, relativePath) {
+    const root = node_path_1.default.resolve(workspaceDir);
+    const destination = node_path_1.default.resolve(root, ...relativePath.split('/'));
+    const relative = node_path_1.default.relative(root, destination);
+    if (!relative || relative.startsWith('..') || node_path_1.default.isAbsolute(relative)) {
+        throw new Error('agent_task_assignment_workspace_file_path_invalid');
+    }
+    return destination;
+}
+async function stageAssignmentWorkspaceFiles(workspaceDir, files) {
+    const normalizedFiles = normalizeAssignmentWorkspaceFiles(files);
+    for (const file of normalizedFiles) {
+        const destination = resolveWorkspaceFileDestination(workspaceDir, file.relativePath);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+        await (0, promises_1.writeFile)(destination, Buffer.from(file.contentBase64, 'base64'));
+    }
+}
+function candidateVersionDirectories(root) {
+    if (!(0, node_fs_1.existsSync)(root)) {
+        return [];
+    }
+    return (0, node_fs_1.readdirSync)(root)
+        .filter((name) => name.trim().length > 0)
+        .sort((left, right) => right.localeCompare(left, undefined, { numeric: true }))
+        .map((name) => node_path_1.default.join(root, name));
+}
+function hasPlaydropPluginReferences(pluginRoot) {
+    return PLAYDROP_PLUGIN_REFERENCE_FILES.every((relativePath) => (0, node_fs_1.existsSync)(node_path_1.default.join(pluginRoot, relativePath)));
+}
+function resolvePlaydropPluginRoot(input = {}) {
+    const homeDir = input.homeDir ?? node_os_1.default.homedir();
+    const env = input.env ?? node_process_1.default.env;
+    const explicitRoot = env.PLAYDROP_WORKER_PLAYDROP_PLUGIN_DIR?.trim();
+    if (explicitRoot) {
+        const resolved = node_path_1.default.resolve(explicitRoot);
+        if (!hasPlaydropPluginReferences(resolved)) {
+            throw new Error(`playdrop_plugin_reference_missing: expected PlayDrop plugin skills and scripts under ${resolved}`);
+        }
+        return resolved;
+    }
+    const candidates = [
+        node_path_1.default.join(homeDir, 'Documents', 'playdrop-plugin'),
+        node_path_1.default.join(homeDir, '.claude', 'plugins', 'marketplaces', 'playdrop'),
+        ...candidateVersionDirectories(node_path_1.default.join(homeDir, '.claude', 'plugins', 'cache', 'playdrop', 'playdrop')),
+        node_path_1.default.join(homeDir, '.codex', 'plugins', 'playdrop'),
+        node_path_1.default.join(homeDir, '.codex', 'plugins', 'cache', 'playdrop', 'playdrop'),
+        ...candidateVersionDirectories(node_path_1.default.join(homeDir, '.codex', 'plugins', 'cache', 'playdrop', 'playdrop')),
+        ...candidateVersionDirectories(node_path_1.default.join(homeDir, '.codex', 'plugins', 'cache', 'olivier-local-plugins', 'playdrop')),
+    ];
+    const pluginRoot = candidates.find(hasPlaydropPluginReferences);
+    if (!pluginRoot) {
+        throw new Error('playdrop_plugin_reference_missing: install or update the PlayDrop plugin so the required skills and scripts are available.');
+    }
+    return pluginRoot;
+}
+async function stagePlaydropPluginReferences(input) {
+    const pluginRoot = node_path_1.default.resolve(input.pluginRoot);
+    if (!hasPlaydropPluginReferences(pluginRoot)) {
+        throw new Error(`playdrop_plugin_reference_missing: expected required PlayDrop plugin skills and scripts under ${pluginRoot}`);
+    }
+    let referenceFiles;
+    if (input.kind === 'GAME_REVIEW') {
+        referenceFiles = PLAYDROP_PLUGIN_GAME_REVIEW_REFERENCE_FILES;
+    }
+    else if (input.kind === 'NEW_GAME' || input.kind === 'GAME_UPDATE') {
+        referenceFiles = PLAYDROP_PLUGIN_CREATION_REFERENCE_FILES;
+    }
+    else {
+        throw new Error(`unsupported_agent_task_kind:${input.kind}`);
+    }
+    const staged = [];
+    for (const relativePath of referenceFiles) {
+        const destinationRelativePath = node_path_1.default.join(STAGED_PLAYDROP_PLUGIN_ROOT, relativePath);
+        const destination = resolveWorkspaceFileDestination(input.workspaceDir, destinationRelativePath);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+        await (0, promises_1.copyFile)(node_path_1.default.join(pluginRoot, relativePath), destination);
+        staged.push(destinationRelativePath.replace(/\\/g, '/'));
+    }
+    return staged;
+}
+// A PlayDrop project root is the topmost directory holding a catalogue.json,
+// the same marker "playdrop project publish" resolves its target from. Nested
+// catalogue.json files belong to the root above them, so the walk stops at the
+// first catalogue.json on each branch.
+function discoverWorkerProjectRoot(workspaceDir) {
+    const roots = [];
+    const walk = (dir) => {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(dir, 'catalogue.json'))) {
+            roots.push(dir);
+            return;
+        }
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            walk(node_path_1.default.join(dir, entry.name));
+        }
+    };
+    walk(workspaceDir);
+    if (roots.length === 0) {
+        throw new Error(`agent_task_no_project: no PlayDrop project with a catalogue.json was found under ${workspaceDir}.`);
+    }
+    if (roots.length > 1) {
+        throw new Error(`agent_task_multiple_projects: found ${roots.length} PlayDrop project roots under ${workspaceDir} (${roots.join(', ')}).`);
+    }
+    return roots[0];
+}
+function writeWorkerTaskState(state) {
+    const file = workerStateFilePath();
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(file), { recursive: true });
+    (0, node_fs_1.writeFileSync)(file, JSON.stringify(state, null, 2));
+}
+function readWorkerTaskState() {
+    const file = workerStateFilePath();
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Number.isInteger(parsed.taskId) || parsed.taskId <= 0) {
+        throw new Error(`invalid_worker_state_file:${file}`);
+    }
+    return parsed;
+}
+function clearWorkerTaskState() {
+    (0, node_fs_1.rmSync)(workerStateFilePath(), { force: true });
+}
+function isWorkerSlackAlertEnabled() {
+    const normalized = node_process_1.default.env.PLAYDROP_WORKER_SLACK_ALERTS?.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function buildWorkerHealthAlertText(input) {
+    return [
+        `PlayDrop Worker ${input.state}`,
+        `env=${input.env}`,
+        `worker=${input.workerName}`,
+        input.taskId ? `task=${input.taskId}` : null,
+        input.detail ? `detail=${input.detail}` : null,
+    ].filter(Boolean).join(' ');
+}
+async function sendWorkerHealthAlert(input) {
+    if (!isWorkerSlackAlertEnabled()) {
+        return;
+    }
+    const token = node_process_1.default.env.PLAYDROP_SLACK_BOT_TOKEN?.trim();
+    if (!token) {
+        throw new Error('missing_playdrop_slack_bot_token');
+    }
+    const channelId = node_process_1.default.env.PLAYDROP_WORKER_SLACK_CHANNEL_ID?.trim();
+    if (!channelId) {
+        throw new Error('missing_playdrop_worker_slack_channel_id');
+    }
+    const response = await fetch(`${SLACK_API_BASE_URL}/chat.postMessage`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${token}`,
+            'content-type': 'application/json; charset=utf-8',
+        },
+        body: JSON.stringify({
+            channel: channelId,
+            text: buildWorkerHealthAlertText(input),
+        }),
+    });
+    const raw = await response.text();
+    const payload = raw ? JSON.parse(raw) : {};
+    if (!response.ok) {
+        throw new Error(`slack_http_error:${response.status}`);
+    }
+    if (payload.ok !== true) {
+        throw new Error(`slack_api_error:${String(payload.error || 'unknown')}`);
+    }
+}
+async function sendWorkerHealthAlertSafely(input) {
+    try {
+        await sendWorkerHealthAlert(input);
+    }
+    catch (error) {
+        console.error(`Worker health alert failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function parsePositiveInteger(value, code) {
+    const parsed = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(code);
+    }
+    return parsed;
+}
+function parseOptionalPct(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    const parsed = typeof value === 'number' ? value : Number.parseInt(String(value), 10);
+    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) {
+        throw new Error('invalid_task_pct');
+    }
+    return parsed;
+}
+function normalizeTaskEventKind(value) {
+    const normalized = value?.trim().toLowerCase().replace(/[\s-]+/g, '_') || 'progress';
+    if (normalized === 'progress') {
+        return normalized;
+    }
+    throw new Error('invalid_task_event_kind');
+}
+function resolveWorkerEventQueueDir() {
+    if (node_process_1.default.env.PLAYDROP_WORKER_CONTEXT !== '1') {
+        return null;
+    }
+    const eventDir = node_process_1.default.env.PLAYDROP_WORKER_EVENT_DIR?.trim();
+    return eventDir || null;
+}
+function enqueueWorkerContextEvent(event) {
+    const eventDir = resolveWorkerEventQueueDir();
+    if (!eventDir) {
+        throw new Error('task_context_event_queue_missing');
+    }
+    (0, node_fs_1.mkdirSync)(eventDir, { recursive: true });
+    const eventId = `${Date.now()}-${crypto.randomUUID()}`;
+    const tmpPath = node_path_1.default.join(eventDir, `${eventId}.tmp`);
+    const finalPath = node_path_1.default.join(eventDir, `${eventId}.json`);
+    (0, node_fs_1.writeFileSync)(tmpPath, JSON.stringify(event), 'utf8');
+    (0, node_fs_1.renameSync)(tmpPath, finalPath);
+}
+function resolveWorkerTaskStateForWrite() {
+    const state = readWorkerTaskState();
+    if (!state) {
+        throw new Error('task_context_missing');
+    }
+    throw new Error('task_context_supervisor_only');
+}
+function isLeaseInvalidError(error) {
+    if (error instanceof types_1.ApiError && error.code === 'agent_task_lease_invalid') {
+        return true;
+    }
+    return error instanceof Error && error.message.includes('agent_task_lease_invalid');
+}
+function isAgentTaskNotRunningError(error) {
+    if (error instanceof types_1.ApiError && error.code === 'agent_task_not_running') {
+        return true;
+    }
+    return error instanceof Error && error.message.includes('agent_task_not_running');
+}
+// A 401 from the API means the stored session is expired or revoked. Backoff
+// can never fix that, so the worker must stop with a visible re-login message
+// instead of retrying forever (spec section 9, session longevity).
+function isWorkerAuthFailureError(error) {
+    return error instanceof types_1.ApiError && error.status === 401;
+}
+function classifyWorkerEventDrainError(error) {
+    if (isWorkerAuthFailureError(error)) {
+        return 'session_expired';
+    }
+    if (isLeaseInvalidError(error)) {
+        return 'lease_invalid';
+    }
+    return null;
+}
+// Throws for claim errors that must stop the worker; returns for transient
+// errors the claim loop may retry with backoff.
+function assertWorkerClaimErrorRetryable(error) {
+    if (isWorkerAuthFailureError(error)) {
+        throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+    }
+    if (error instanceof types_1.ApiError && error.status === 403) {
+        throw new Error(`worker_claim_forbidden: the server rejected this worker session (${error.message}).`);
+    }
+}
+function resolvePlaydropAssetRequirementFromText(value) {
+    const text = typeof value === 'string' ? value.toLowerCase() : '';
+    if (!text.trim()) {
+        return null;
+    }
+    const mentionsPlaydrop = /\bplay\s*drop\b|\bplaydrop\b/.test(text);
+    if (!mentionsPlaydrop) {
+        return null;
+    }
+    if (/\basset\s*pack(s)?\b|\bpack(s)?\b/.test(text)) {
+        return 'PACK';
+    }
+    if (/\basset(s)?\b|\bsprite(s)?\b|\bmodel(s)?\b|\bart\b|\bcharacter(s)?\b|\bprop(s)?\b/.test(text)) {
+        return 'ASSET_OR_PACK';
+    }
+    return null;
+}
+function readCodexAuthenticated(homeDir = node_os_1.default.homedir()) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(homeDir, '.codex', 'auth.json'), 'utf8'));
+        const tokens = parsed.tokens;
+        return Boolean(tokens?.id_token || parsed.auth_mode === 'apikey');
+    }
+    catch {
+        return false;
+    }
+}
+function probeNpmVersion() {
+    const result = (0, shellProbe_1.runShell)('npm --version');
+    const version = result.output.trim().split('\n')[0]?.trim() ?? '';
+    if (result.exitCode !== 0 || !version) {
+        throw new Error(`worker_preflight_npm_missing: "npm --version" exited with code ${result.exitCode}.`);
+    }
+    return version;
+}
+function probePlaywrightChromium() {
+    let playwrightCore;
+    let packageJson;
+    try {
+        playwrightCore = requireFromWorker('playwright-core');
+        packageJson = requireFromWorker('playwright-core/package.json');
+    }
+    catch {
+        throw new Error('worker_preflight_playwright_missing: install Playwright before starting the worker.');
+    }
+    const executablePath = playwrightCore.chromium.executablePath();
+    const version = typeof packageJson.version === 'string' && packageJson.version.trim() ? packageJson.version.trim() : 'unknown';
+    const chromiumInstalled = (0, node_fs_1.existsSync)(executablePath);
+    if (!chromiumInstalled) {
+        throw new Error(`worker_preflight_chromium_missing: install Playwright Chromium before starting the worker (${executablePath}).`);
+    }
+    return { version, chromiumInstalled };
+}
+function readWorkerModelList(agent, envName) {
+    const raw = node_process_1.default.env[envName];
+    if (typeof raw !== 'string' || raw.trim().length === 0) {
+        return [...types_1.AGENT_TASK_MODEL_VALUES_BY_AGENT[agent]];
+    }
+    const values = raw
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => (0, types_1.normalizeAgentTaskModel)(agent, entry));
+    const unsupported = raw
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .filter((entry) => !(0, types_1.normalizeAgentTaskModel)(agent, entry));
+    if (unsupported.length > 0) {
+        throw new Error(`worker_preflight_unsupported_model_list:${envName}:${unsupported.join(',')}`);
+    }
+    const unique = Array.from(new Set(values));
+    if (unique.length === 0 || unique.some((model) => !model || model.length > 120)) {
+        throw new Error(`worker_preflight_invalid_model_list:${envName}`);
+    }
+    return unique;
+}
+function parseEnvLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+        return null;
+    }
+    const withoutExport = trimmed.startsWith('export ') ? trimmed.slice('export '.length).trim() : trimmed;
+    const separator = withoutExport.indexOf('=');
+    if (separator <= 0) {
+        return null;
+    }
+    const key = withoutExport.slice(0, separator).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        return null;
+    }
+    let value = withoutExport.slice(separator + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"'))
+        || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+    }
+    return { key, value };
+}
+function loadWorkerEnvFile(envName, cwd = node_process_1.default.cwd()) {
+    const normalizedEnv = envName?.trim();
+    if (!normalizedEnv || normalizedEnv === 'prod') {
+        return null;
+    }
+    if (!/^[A-Za-z0-9_-]+$/.test(normalizedEnv)) {
+        throw new Error(`invalid_worker_env:${normalizedEnv}`);
+    }
+    const envPath = node_path_1.default.join(cwd, 'infra', `.env.${normalizedEnv}`);
+    if (!(0, node_fs_1.existsSync)(envPath)) {
+        return null;
+    }
+    const contents = (0, node_fs_1.readFileSync)(envPath, 'utf8');
+    for (const line of contents.split(/\r?\n/)) {
+        const entry = parseEnvLine(line);
+        if (!entry || node_process_1.default.env[entry.key] !== undefined) {
+            continue;
+        }
+        node_process_1.default.env[entry.key] = entry.value;
+    }
+    return envPath;
+}
+function buildWorkerCapabilities(input) {
+    const codexVersion = typeof input === 'string' ? input : input.codexVersion?.trim() || null;
+    const codexAuthenticated = typeof input === 'string' ? true : input.codexAuthenticated === true;
+    const claudeVersion = typeof input === 'string' ? null : input.claudeVersion?.trim() || null;
+    const claudeAuthenticated = typeof input === 'string' ? false : input.claudeAuthenticated === true;
+    const npmVersion = typeof input === 'string' ? null : input.npmVersion?.trim() || null;
+    const playwright = typeof input === 'string' ? null : input.playwright ?? null;
+    const maxParallelTasks = typeof input === 'string'
+        ? DEFAULT_WORKER_MAX_PARALLEL_TASKS
+        : input.maxParallelTasks ?? DEFAULT_WORKER_MAX_PARALLEL_TASKS;
+    const runningTaskCount = typeof input === 'string' ? 0 : input.runningTaskCount ?? 0;
+    const degradedReasons = [];
+    const agents = [];
+    if (codexVersion) {
+        if (!codexAuthenticated) {
+            degradedReasons.push('codex_not_authenticated');
+        }
+        agents.push({
+            agent: 'CODEX',
+            cliVersion: codexVersion,
+            authenticated: codexAuthenticated,
+            models: readWorkerModelList('CODEX', 'PLAYDROP_WORKER_CODEX_MODELS'),
+            ready: codexAuthenticated,
+        });
+    }
+    if (claudeVersion) {
+        if (!claudeAuthenticated) {
+            degradedReasons.push('claude_not_authenticated');
+        }
+        agents.push({
+            agent: 'CLAUDE_CODE',
+            cliVersion: claudeVersion,
+            authenticated: claudeAuthenticated,
+            models: readWorkerModelList('CLAUDE_CODE', 'PLAYDROP_WORKER_CLAUDE_MODELS'),
+            ready: claudeAuthenticated,
+        });
+    }
+    if (agents.length === 0) {
+        throw new Error('agent_cli_not_found: install and authenticate Codex or Claude Code before starting a PlayDrop worker.');
+    }
+    return {
+        agent: agents[0].agent,
+        supportedKinds: [...WORKER_SUPPORTED_KINDS],
+        maxParallelTasks,
+        runningTaskCount,
+        cliVersion: (0, clientInfo_1.getCliVersion)(),
+        nodeVersion: node_process_1.default.versions.node,
+        agents,
+        ready: agents.some((agent) => agent.ready === true),
+        degradedReasons,
+        ...(npmVersion ? { npmVersion } : {}),
+        ...(playwright ? { playwright } : {}),
+        os: node_process_1.default.platform,
+        arch: node_process_1.default.arch,
+    };
+}
+function buildWorkerClaimBody(input) {
+    return {
+        workerKey: input.workerKey,
+        capabilities: {
+            ...input.capabilities,
+            runningTaskCount: input.runningTaskCount ?? input.capabilities.runningTaskCount ?? 0,
+        },
+    };
+}
+function resolveWorkerBaseSource(value) {
+    if (!value) {
+        throw new Error('agent_task_assignment_missing_base_source');
+    }
+    if (typeof value.appName !== 'string' || !value.appName.trim()) {
+        throw new Error('agent_task_base_app_name_missing');
+    }
+    if (typeof value.version !== 'string' || !value.version.trim()) {
+        throw new Error('agent_task_base_app_version_missing');
+    }
+    if (typeof value.appId !== 'number' || !Number.isInteger(value.appId) || value.appId <= 0) {
+        throw new Error('agent_task_base_app_id_missing');
+    }
+    if (typeof value.appVersionId !== 'number' || !Number.isInteger(value.appVersionId) || value.appVersionId <= 0) {
+        throw new Error('agent_task_base_app_version_id_missing');
+    }
+    return {
+        appName: value.appName.trim(),
+        version: value.version.trim(),
+        appId: value.appId,
+        appVersionId: value.appVersionId,
+    };
+}
+// Extracts a zip archive into targetDir using fflate (already a CLI
+// dependency; see src/commands/create.ts). Entries that resolve outside the
+// target directory throw instead of being skipped: a base source archive with
+// traversal entries is corrupt and must fail the task loudly.
+function extractZipArchive(zipBuffer, targetDir) {
+    const files = (0, fflate_1.unzipSync)(zipBuffer);
+    const names = Object.keys(files);
+    if (names.length === 0) {
+        throw new Error('agent_task_base_source_empty: the downloaded source archive contained no files.');
+    }
+    const resolvedTarget = node_path_1.default.resolve(targetDir);
+    const written = [];
+    for (const originalName of names) {
+        const name = originalName.replace(/\\/g, '/');
+        const destination = node_path_1.default.resolve(resolvedTarget, name);
+        if (destination !== resolvedTarget && !destination.startsWith(resolvedTarget + node_path_1.default.sep)) {
+            throw new Error(`agent_task_base_source_unsafe_entry: archive entry "${originalName}" escapes the staging directory.`);
+        }
+        if (name.endsWith('/')) {
+            (0, node_fs_1.mkdirSync)(destination, { recursive: true });
+            continue;
+        }
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(destination), { recursive: true });
+        (0, node_fs_1.writeFileSync)(destination, Buffer.from(files[originalName]));
+        written.push(name);
+    }
+    return written;
+}
+// Reads the version string of the named app from the catalogue.json at the
+// project root. Used for the staged base version and the version-bump guard.
+function readWorkerProjectVersion(projectDir, appName) {
+    const cataloguePath = node_path_1.default.join(projectDir, 'catalogue.json');
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(cataloguePath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`agent_task_catalogue_unreadable: could not read ${cataloguePath} (${error instanceof Error ? error.message : String(error)}).`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`agent_task_catalogue_invalid_json: ${cataloguePath} is not valid JSON.`);
+    }
+    const apps = parsed?.apps;
+    if (!Array.isArray(apps)) {
+        throw new Error(`agent_task_catalogue_apps_missing: ${cataloguePath} has no "apps" array.`);
+    }
+    const entry = apps.find((candidate) => Boolean(candidate) && typeof candidate === 'object' && candidate.name === appName);
+    if (!entry) {
+        throw new Error(`agent_task_catalogue_app_missing: no app named "${appName}" in ${cataloguePath}.`);
+    }
+    const version = typeof entry.version === 'string' ? entry.version.trim() : '';
+    if (!version) {
+        throw new Error(`agent_task_catalogue_version_missing: app "${appName}" in ${cataloguePath} has no version string.`);
+    }
+    return version;
+}
+function normalizePreviewString(value) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    return normalized || undefined;
+}
+function normalizePreviewStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const values = value
+        .map((entry) => normalizePreviewString(entry))
+        .filter((entry) => Boolean(entry));
+    return values.length > 0 ? values : undefined;
+}
+function normalizePreviewSurfaceTargets(value) {
+    if (Array.isArray(value)) {
+        return normalizePreviewStringArray(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const targets = Object.entries(value)
+        .filter(([, enabled]) => enabled === true)
+        .map(([target]) => target.trim())
+        .filter(Boolean);
+    return targets.length > 0 ? targets : undefined;
+}
+function countWorkspaceFiles(workspaceDir) {
+    let count = 0;
+    const walk = (dir) => {
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name === '.git') {
+                continue;
+            }
+            const entryPath = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(entryPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                count += 1;
+            }
+        }
+    };
+    walk(workspaceDir);
+    return count;
+}
+function buildCataloguePreviewPayload(cataloguePath, workspaceDir = node_path_1.default.dirname(cataloguePath)) {
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(cataloguePath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`agent_task_catalogue_preview_unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const root = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : null;
+    if (!root) {
+        throw new Error('agent_task_catalogue_preview_invalid');
+    }
+    const app = Array.isArray(root.apps)
+        ? root.apps.find((candidate) => Boolean(candidate) && typeof candidate === 'object' && !Array.isArray(candidate))
+        : root;
+    if (!app) {
+        throw new Error('agent_task_catalogue_preview_app_missing');
+    }
+    const catalogue = {};
+    const appName = normalizePreviewString(app.name ?? app.appName);
+    if (appName)
+        catalogue.appName = appName;
+    const displayName = normalizePreviewString(app.displayName);
+    if (displayName)
+        catalogue.displayName = displayName;
+    const description = normalizePreviewString(app.description);
+    if (description)
+        catalogue.description = description;
+    const emoji = normalizePreviewString(app.emoji);
+    if (emoji)
+        catalogue.emoji = emoji;
+    const color = normalizePreviewString(app.color);
+    if (color)
+        catalogue.color = color;
+    const version = normalizePreviewString(app.version);
+    if (version)
+        catalogue.version = version;
+    const releaseNotes = normalizePreviewString(app.releaseNotes);
+    if (releaseNotes)
+        catalogue.releaseNotes = releaseNotes;
+    const listing = app.listing && typeof app.listing === 'object' && !Array.isArray(app.listing)
+        ? app.listing
+        : {};
+    const heroPortraitPath = normalizePreviewString(listing.heroPortrait ?? listing.heroPortraitPath ?? app.heroPortraitPath);
+    if (heroPortraitPath)
+        catalogue.heroPortraitPath = heroPortraitPath;
+    const heroLandscapePath = normalizePreviewString(listing.heroLandscape ?? listing.heroLandscapePath ?? app.heroLandscapePath);
+    if (heroLandscapePath)
+        catalogue.heroLandscapePath = heroLandscapePath;
+    const surfaceTargets = normalizePreviewSurfaceTargets(app.surfaceTargets);
+    if (surfaceTargets)
+        catalogue.surfaceTargets = surfaceTargets;
+    const tags = normalizePreviewStringArray(app.tags);
+    if (tags)
+        catalogue.tags = tags;
+    const workspace = {
+        filesChanged: countWorkspaceFiles(workspaceDir),
+    };
+    const entryPoint = normalizePreviewString(app.entryPoint ?? app.file);
+    if (entryPoint) {
+        workspace.entryPoint = entryPoint;
+    }
+    return { catalogue, workspace };
+}
+function normalizeQueuedWorkerEvent(value) {
+    const object = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+    if (!object) {
+        throw new Error('agent_task_worker_event_invalid');
+    }
+    const kind = object.kind === 'progress' || object.kind === 'catalogue_preview'
+        ? object.kind
+        : null;
+    if (!kind) {
+        throw new Error('agent_task_worker_event_kind_invalid');
+    }
+    const message = typeof object.message === 'string' ? object.message.trim() : '';
+    if (!message) {
+        throw new Error('agent_task_worker_event_message_missing');
+    }
+    const phase = typeof object.phase === 'string' && object.phase.trim()
+        ? object.phase.trim()
+        : null;
+    const pct = object.pct === undefined || object.pct === null
+        ? null
+        : parseOptionalPct(object.pct);
+    const payload = object.payload && typeof object.payload === 'object' && !Array.isArray(object.payload)
+        ? object.payload
+        : undefined;
+    if (kind === 'catalogue_preview' && !payload) {
+        throw new Error('agent_task_worker_event_payload_missing');
+    }
+    if (kind === 'progress') {
+        return { kind, phase, message, pct };
+    }
+    return { kind, phase, message, pct, payload };
+}
+async function drainWorkerEventQueue(input) {
+    if (!(0, node_fs_1.existsSync)(input.eventDir)) {
+        return;
+    }
+    const entries = (0, node_fs_1.readdirSync)(input.eventDir)
+        .filter((entry) => entry.endsWith('.json'))
+        .sort();
+    for (const entry of entries) {
+        const filePath = node_path_1.default.join(input.eventDir, entry);
+        const raw = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        const event = normalizeQueuedWorkerEvent(JSON.parse(raw));
+        await input.client.workerCreateAgentTaskEvent(input.taskId, {
+            workerKey: input.workerKey,
+            leaseToken: input.leaseToken,
+            kind: event.kind,
+            phase: event.phase,
+            message: event.message,
+            pct: event.pct,
+            ...(event.payload ? { payload: event.payload } : {}),
+        });
+        (0, node_fs_1.rmSync)(filePath, { force: true });
+    }
+}
+// Pre-publish guard for GAME_UPDATE tasks: the server rejects a duplicate
+// version anyway, but failing here gives the task a precise error code.
+function assertWorkerProjectVersionBumped(input) {
+    if (input.projectVersion === input.baseVersion) {
+        throw new Error(`agent_task_version_not_bumped: app "${input.appName}" version is still "${input.baseVersion}"; the update must bump the catalogue.json version before publish.`);
+    }
+}
+// Downloads the base app source archive and unzips it into the workspace so
+// the project root (catalogue.json) lands inside the workspace before Codex
+// starts. Returns the staged project root and its catalogue version string.
+async function stageWorkerBaseAppSource(input) {
+    const { blob } = await input.client.downloadAppSource(input.creatorUsername, input.baseApp.appName, input.baseApp.version);
+    const buffer = Buffer.from(await blob.arrayBuffer());
+    const stagingDir = node_path_1.default.join(input.workspaceDir, input.baseApp.appName);
+    (0, node_fs_1.mkdirSync)(stagingDir, { recursive: true });
+    extractZipArchive(new Uint8Array(buffer), stagingDir);
+    const stagedProjectDir = discoverWorkerProjectRoot(stagingDir);
+    const stagedBaseVersion = readWorkerProjectVersion(stagedProjectDir, input.baseApp.appName);
+    return { stagedProjectDir, stagedBaseVersion };
+}
+function resolveCodexModel(model) {
+    const normalized = model.trim();
+    if (!normalized) {
+        throw new Error('agent_task_assignment_model_missing');
+    }
+    const effortMatch = normalized.match(/^(.*)-(low|medium|high|extra-high|xhigh|max)$/);
+    if (effortMatch?.[1] && effortMatch[2]) {
+        const effort = effortMatch[2] === 'extra-high' ? 'xhigh' : effortMatch[2];
+        return { model: effortMatch[1], reasoningEffort: effort };
+    }
+    return { model: normalized, reasoningEffort: 'medium' };
+}
+function resolveClaudeModel(model) {
+    const normalized = model.trim();
+    if (!normalized) {
+        throw new Error('agent_task_assignment_model_missing');
+    }
+    const effortMatch = normalized.match(/^(.*)-(low|medium|high|xhigh|max)$/);
+    if (effortMatch?.[1] && effortMatch[2]) {
+        return { model: resolveClaudeRuntimeModel(effortMatch[1]), effort: effortMatch[2] };
+    }
+    return { model: resolveClaudeRuntimeModel(normalized), effort: null };
+}
+function resolveClaudeRuntimeModel(model) {
+    if (model === 'claude-haiku-4-5') {
+        return 'claude-haiku-4-5-20251001';
+    }
+    return model;
+}
+async function runCodex(input) {
+    return await (0, runtime_1.runLoggedProcess)({
+        command: 'codex',
+        args: (0, runtime_1.buildCodexExecArgs)({
+            workspaceDir: input.workspaceDir,
+            model: input.codexModel.model,
+            reasoningEffort: input.codexModel.reasoningEffort,
+            networkAccess: (0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_AGENT_NETWORK_ACCESS', false),
+            sandboxMode: (0, runtime_1.readCodexSandboxMode)(),
+        }),
+        cwd: input.workspaceDir,
+        env: (0, runtime_1.buildWorkerChildEnv)({
+            binDir: input.binDir,
+            taskId: input.taskId,
+            attempt: input.attempt,
+            envName: input.envName,
+            eventDir: input.eventDir,
+            devPort: input.devPort,
+        }),
+        stdin: input.prompt,
+        timeoutMs: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CODEX_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
+        maxOutputChars: runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS,
+        onTranscriptChunks: input.onTranscriptChunks,
+        transcriptFlushIntervalMs: runtime_1.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS,
+        onChild: input.onChild,
+    });
+}
+async function runClaude(input) {
+    const denyReadRoots = resolveClaudeDenyReadRoots(input.workspaceDir);
+    return await (0, runtime_1.runLoggedProcess)({
+        command: 'claude',
+        args: (0, runtime_1.buildClaudeExecArgs)({
+            ...input.claudeModel,
+            workspaceDir: input.workspaceDir,
+            denyReadRoots,
+            pluginDir: input.playdropPluginRoot,
+        }),
+        cwd: input.workspaceDir,
+        env: (0, runtime_1.buildWorkerChildEnv)({
+            binDir: input.binDir,
+            taskId: input.taskId,
+            attempt: input.attempt,
+            envName: input.envName,
+            eventDir: input.eventDir,
+            devPort: input.devPort,
+        }),
+        stdin: input.prompt,
+        timeoutMs: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CLAUDE_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
+        maxOutputChars: runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS,
+        onTranscriptChunks: input.onTranscriptChunks,
+        transcriptFlushIntervalMs: runtime_1.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS,
+        onChild: input.onChild,
+    });
+}
+function isPathInside(parent, child) {
+    const relative = node_path_1.default.relative(parent, child);
+    return relative === '' || (!!relative && !relative.startsWith('..') && !node_path_1.default.isAbsolute(relative));
+}
+function resolveClaudeDenyReadRoots(workspaceDir) {
+    const workspaceRoot = node_path_1.default.resolve(workspaceDir);
+    const candidates = new Set();
+    candidates.add(node_process_1.default.cwd());
+    const extra = node_process_1.default.env.PLAYDROP_WORKER_CLAUDE_DENY_ROOTS?.trim();
+    if (extra) {
+        for (const entry of extra.split(',')) {
+            const root = entry.trim();
+            if (root) {
+                candidates.add(root);
+            }
+        }
+    }
+    const roots = [];
+    for (const candidate of candidates) {
+        const root = node_path_1.default.resolve(candidate);
+        if (root === workspaceRoot || isPathInside(root, workspaceRoot)) {
+            continue;
+        }
+        roots.push(root);
+    }
+    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 buildAgentRunResult(result) {
+    return {
+        exitCode: result.exitCode,
+        signal: result.signal,
+        timedOut: result.timedOut,
+        tokensUsed: result.tokensUsed,
+    };
+}
+function buildSupervisorFailureRunResult(message) {
+    return {
+        exitCode: null,
+        signal: null,
+        stdout: '',
+        stderr: message,
+        outputTail: message,
+        timedOut: false,
+        tokenUsage: {
+            inputTokens: null,
+            outputTokens: null,
+            cacheCreationInputTokens: null,
+            cacheReadInputTokens: null,
+            totalTokens: null,
+            rawProviderUsage: null,
+            usageParseError: 'agent_not_started',
+        },
+        tokensUsed: null,
+    };
+}
+function stripStagedPlaydropPluginPrefix(value) {
+    const normalized = value.trim().replace(/\\/g, '/');
+    const pluginPrefix = `${STAGED_PLAYDROP_PLUGIN_ROOT}/`;
+    if (normalized.startsWith(pluginPrefix)) {
+        return normalized.slice(pluginPrefix.length);
+    }
+    return normalized;
+}
+function normalizeTelemetrySkillPaths(stagedPaths) {
+    return Array.from(new Set(stagedPaths.map(stripStagedPlaydropPluginPrefix).filter(Boolean))).sort();
+}
+function collectObservedPlaydropSkillPaths(output, availablePaths) {
+    const observed = new Set();
+    for (const availablePath of availablePaths) {
+        if (output.includes(availablePath)
+            || output.includes(`${STAGED_PLAYDROP_PLUGIN_ROOT}/${availablePath}`)) {
+            observed.add(availablePath);
+        }
+    }
+    return [...observed].sort();
+}
+function readProviderAccountLabel(target) {
+    const label = node_process_1.default.env.PLAYDROP_WORKER_AGENT_ACCOUNT_LABEL?.trim() || null;
+    if (target === 'FIRST_PARTY' && !label) {
+        throw new Error('missing_playdrop_worker_agent_account_label');
+    }
+    return label;
+}
+function resolveTelemetryStatus(value) {
+    if (value === 'QUEUED') {
+        throw new Error('invalid_agent_task_run_status');
+    }
+    return value;
+}
+async function recordAgentRunTelemetry(input) {
+    const observedSkillPaths = new Set(input.observedSkillPaths ?? []);
+    for (const path of collectObservedPlaydropSkillPaths(`${input.result.stdout}\n${input.result.stderr}\n${input.result.outputTail}`, input.availableSkillPaths)) {
+        observedSkillPaths.add(path);
+    }
+    await input.client.workerRecordAgentTaskRunTelemetry(input.task.id, {
+        workerKey: input.workerKey,
+        leaseToken: input.leaseToken,
+        attempt: input.task.attempts,
+        agent: input.assignment.agent,
+        requestedModel: input.assignment.model,
+        resolvedRuntimeModel: input.resolvedRuntimeModel,
+        reasoningEffort: input.reasoningEffort,
+        providerAccountLabel: input.providerAccountLabel,
+        status: resolveTelemetryStatus(input.status),
+        exitCode: input.result.exitCode,
+        signal: input.result.signal,
+        timedOut: input.result.timedOut,
+        tokenUsage: {
+            inputTokens: input.result.tokenUsage.inputTokens,
+            outputTokens: input.result.tokenUsage.outputTokens,
+            cacheCreationInputTokens: input.result.tokenUsage.cacheCreationInputTokens,
+            cacheReadInputTokens: input.result.tokenUsage.cacheReadInputTokens,
+            totalTokens: input.result.tokenUsage.totalTokens,
+            rawProviderUsage: input.result.tokenUsage.rawProviderUsage,
+            usageParseError: input.result.tokenUsage.usageParseError,
+        },
+        availableSkillPaths: [...input.availableSkillPaths],
+        observedSkillPaths: [...observedSkillPaths].sort(),
+        startedAt: input.startedAt.toISOString(),
+        completedAt: input.completedAt.toISOString(),
+    });
+}
+function providerNameForAgent(agent) {
+    return agent === 'CLAUDE_CODE' ? 'claude' : 'codex';
+}
+function extractProviderStatusCode(text) {
+    const jsonStatus = /"api_error_status"\s*:\s*(\d{3})/.exec(text);
+    if (jsonStatus?.[1]) {
+        return Number(jsonStatus[1]);
+    }
+    const apiStatus = /\bAPI Error:\s*(\d{3})\b/i.exec(text);
+    if (apiStatus?.[1]) {
+        return Number(apiStatus[1]);
+    }
+    return null;
+}
+function buildAgentFailureCode(agent, result) {
+    const provider = providerNameForAgent(agent);
+    const combinedOutput = `${result.outputTail}\n${result.stderr}\n${result.stdout}`;
+    const providerStatus = extractProviderStatusCode(combinedOutput);
+    if (providerStatus === 529 || (/\b529\b/.test(combinedOutput) && /\boverloaded?\b/i.test(combinedOutput))) {
+        return `agent_provider_overloaded:${provider}:529`;
+    }
+    if (/\boverloaded?\b/i.test(combinedOutput)) {
+        return `agent_provider_overloaded:${provider}`;
+    }
+    if (result.timedOut) {
+        return `agent_provider_timeout:${provider}`;
+    }
+    if (result.exitCode !== null) {
+        return `agent_unknown_exit:${provider}:${result.exitCode}`;
+    }
+    if (result.signal) {
+        return `agent_unknown_exit:${provider}:signal_${result.signal}`;
+    }
+    return `agent_unknown_exit:${provider}`;
+}
+function describeAgentFailureForEvent(errorCode) {
+    const [code, provider, detail] = errorCode.split(':');
+    const providerLabel = provider === 'claude' ? 'Claude' : provider === 'codex' ? 'Codex' : 'The agent provider';
+    if (code === 'agent_provider_overloaded') {
+        return detail
+            ? `${providerLabel} is overloaded (API ${detail}). Retry this task in a few minutes.`
+            : `${providerLabel} is overloaded. Retry this task in a few minutes.`;
+    }
+    if (code === 'agent_provider_timeout') {
+        return `${providerLabel} timed out before completing the task. Retry this task when the provider is healthy.`;
+    }
+    if (code === 'worker_shutdown') {
+        return 'The worker stopped while running this task. Start the worker again, then retry the task.';
+    }
+    if (code === 'agent_unknown_exit') {
+        return detail
+            ? `${providerLabel} exited before completing the task (${detail}). Check the transcript, then retry.`
+            : `${providerLabel} exited before completing the task. Check the transcript, then retry.`;
+    }
+    return 'The agent stopped before completing the task. Check the transcript, then retry.';
+}
+function normalizeWorkerFailureErrorCode(message) {
+    const trimmed = message.trim();
+    const match = /^([a-z0-9_]+)(?::|\b)/.exec(trimmed);
+    return match?.[1] ?? trimmed;
+}
+async function createLocalPlaydropShim(workspaceDir) {
+    const binDir = node_path_1.default.join(workspaceDir, 'bin');
+    await (0, promises_1.mkdir)(binDir, { recursive: true });
+    const cliEntrypoint = node_path_1.default.resolve(node_process_1.default.argv[1] ?? node_path_1.default.join(__dirname, '..', 'index.js'));
+    const shimPath = node_path_1.default.join(binDir, 'playdrop');
+    await (0, promises_1.writeFile)(shimPath, `#!/bin/sh\nexec ${JSON.stringify(node_process_1.default.execPath)} ${JSON.stringify(cliEntrypoint)} "$@"\n`, 'utf8');
+    await (0, promises_1.chmod)(shimPath, 0o755);
+    return binDir;
+}
+function probeCodexInstallation() {
+    const probe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)('codex'));
+    if (probe.exitCode !== 0 || !probe.output.trim()) {
+        return null;
+    }
+    const versionResult = (0, shellProbe_1.runShell)('codex --version');
+    const match = /(\d+\.\d+\.\d+\S*)/.exec(versionResult.output);
+    if (!match?.[1]) {
+        throw new Error(`codex_version_check_failed: "codex --version" exited with code ${versionResult.exitCode} and reported no version. Output: ${versionResult.output.slice(0, 200)}`);
+    }
+    if (versionResult.exitCode !== 0) {
+        // Codex 0.128.0 intermittently segfaults on exit after printing the
+        // version; the printed version is the probe's success criterion.
+        console.warn(`codex --version exited uncleanly (code ${versionResult.exitCode}) but reported ${match[1]}; continuing.`);
+    }
+    return { codexVersion: match[1] };
+}
+function probeClaudeInstallation() {
+    const probe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)('claude'));
+    if (probe.exitCode !== 0 || !probe.output.trim()) {
+        return null;
+    }
+    const versionResult = (0, shellProbe_1.runShell)('claude --version');
+    const match = /(\d+\.\d+\.\d+\S*)/.exec(versionResult.output);
+    if (!match?.[1] || versionResult.exitCode !== 0) {
+        throw new Error(`claude_version_check_failed: "claude --version" exited with code ${versionResult.exitCode} and reported no version. Output: ${versionResult.output.slice(0, 200)}`);
+    }
+    return { claudeVersion: match[1] };
+}
+function readClaudeAuthenticated() {
+    const status = (0, shellProbe_1.runShell)('claude auth status --text');
+    return status.exitCode === 0;
+}
+async function failTaskWithRetry(client, taskId, body) {
+    try {
+        await client.workerFailAgentTask(taskId, body);
+    }
+    catch (firstError) {
+        if (isAgentTaskNotRunningError(firstError)) {
+            return;
+        }
+        await sleep(FAIL_REPORT_RETRY_DELAY_MS);
+        try {
+            await client.workerFailAgentTask(taskId, body);
+        }
+        catch (secondError) {
+            if (isAgentTaskNotRunningError(secondError)) {
+                return;
+            }
+            console.error(`FAILED to report agent task ${taskId} failure after retry. ` +
+                `first=${firstError instanceof Error ? firstError.message : String(firstError)} ` +
+                `second=${secondError instanceof Error ? secondError.message : String(secondError)}`);
+        }
+    }
+}
+async function fetchTaskDetail(client, target, taskId) {
+    if (target === 'FIRST_PARTY') {
+        const detail = await client.adminGetAgentTask(taskId);
+        return { task: detail.task };
+    }
+    return await client.getAgentTask(taskId);
+}
+async function startWorker(options = {}) {
+    loadWorkerEnvFile(options.env);
+    await (0, commandContext_1.withEnvironment)('worker start', 'Starting the PlayDrop worker', async ({ client, env }) => {
+        let me;
+        try {
+            me = await client.me();
+        }
+        catch (error) {
+            if (isWorkerAuthFailureError(error)) {
+                throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+            }
+            throw error;
+        }
+        const username = me.user?.username?.trim();
+        if (!username) {
+            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);
+        const codexVersion = probeCodexInstallation()?.codexVersion ?? null;
+        const claudeVersion = probeClaudeInstallation()?.claudeVersion ?? null;
+        const codexAuthenticated = codexVersion ? readCodexAuthenticated() : false;
+        const claudeAuthenticated = claudeVersion ? readClaudeAuthenticated() : false;
+        const npmVersion = probeNpmVersion();
+        const playwright = probePlaywrightChromium();
+        const playdropPluginRoot = resolvePlaydropPluginRoot();
+        const workerKey = (0, config_1.getOrCreateWorkerKey)();
+        const workerName = options.name?.trim() || `${username} - ${node_os_1.default.hostname()}`;
+        const maxParallelTasks = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_MAX_PARALLEL_TASKS', DEFAULT_WORKER_MAX_PARALLEL_TASKS);
+        const capabilities = buildWorkerCapabilities({
+            codexVersion,
+            codexAuthenticated,
+            claudeVersion,
+            claudeAuthenticated,
+            npmVersion,
+            playwright,
+            maxParallelTasks,
+            runningTaskCount: 0,
+        });
+        if (!capabilities.ready) {
+            const reasons = Array.isArray(capabilities.degradedReasons) && capabilities.degradedReasons.length > 0
+                ? capabilities.degradedReasons.join(', ')
+                : 'no ready agent';
+            throw new Error(`worker_preflight_failed: ${reasons}`);
+        }
+        const activeTaskIds = new Set();
+        const activeTaskRuns = new Map();
+        const activeTerminators = new Map();
+        const activeDevPorts = new Set();
+        const workerDevPortBase = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_DEV_PORT_BASE', DEFAULT_WORKER_DEV_PORT_BASE);
+        let sessionExpired = false;
+        let shuttingDown = false;
+        let shutdownSignal = null;
+        let crashed = false;
+        let fatalTaskError = null;
+        let presenceTimer = null;
+        const firstActiveTaskId = () => activeTaskIds.values().next().value ?? null;
+        const terminateActiveTasks = () => {
+            for (const terminate of activeTerminators.values()) {
+                terminate();
+            }
+        };
+        const currentCapabilities = () => ({
+            ...capabilities,
+            runningTaskCount: activeTaskRuns.size,
+        });
+        const presenceBody = () => ({
+            workerKey,
+            name: workerName,
+            environment: env,
+            capabilities: currentCapabilities(),
+        });
+        const recordFatalTaskError = (error) => {
+            if (!fatalTaskError) {
+                fatalTaskError = error instanceof Error ? error : new Error(String(error));
+            }
+            shuttingDown = true;
+            terminateActiveTasks();
+        };
+        const signalHandler = (signal) => {
+            shutdownSignal = signal;
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            // Task runs finish their own lifecycle (flush, fail, clean) before exit.
+            terminateActiveTasks();
+        };
+        node_process_1.default.once('SIGINT', signalHandler);
+        node_process_1.default.once('SIGTERM', signalHandler);
+        console.log(`PlayDrop Worker started as "${workerName}" (${target}).`);
+        await sendWorkerHealthAlertSafely({ state: 'started', env, workerName });
+        // 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 = () => {
+            if (sessionExpired) {
+                return;
+            }
+            sessionExpired = true;
+            console.error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+            terminateActiveTasks();
+        };
+        try {
+            await client.workerPresence(presenceBody());
+        }
+        catch (error) {
+            if (isWorkerAuthFailureError(error)) {
+                throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+            }
+            throw error;
+        }
+        presenceTimer = setInterval(() => {
+            client.workerPresence(presenceBody()).catch((error) => {
+                if (isWorkerAuthFailureError(error)) {
+                    handleSessionExpiry();
+                    return;
+                }
+                console.error(`Worker presence heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, HEARTBEAT_INTERVAL_MS);
+        const runClaimedTask = async (claim, devPort) => {
+            const task = claim.task;
+            if (!task) {
+                throw new Error('agent_task_claim_missing_task');
+            }
+            const leaseToken = claim.leaseToken?.trim();
+            if (!leaseToken) {
+                throw new Error('agent_task_claim_missing_lease_token');
+            }
+            // The lease token lives only in supervisor memory, never in the task
+            // workspace, on-disk worker state, or the agent child environment.
+            let heartbeatTimer = null;
+            let eventDrainTimer = null;
+            let eventDrainPromise = Promise.resolve();
+            let fenced = false;
+            let retainWorkspace = false;
+            let workspaceDir = null;
+            let availableSkillPaths = [];
+            const observedSkillPaths = new Set();
+            let assignment = null;
+            let providerAccountLabel = null;
+            let resolvedRuntimeModel = task.model;
+            let reasoningEffort = null;
+            let agentStartedAt = null;
+            let agentCompletedAt = null;
+            let agentResult = null;
+            let telemetryReported = false;
+            const reportTelemetry = async (status, setupError) => {
+                if (!assignment) {
+                    return;
+                }
+                const completedAt = agentCompletedAt ?? new Date();
+                await recordAgentRunTelemetry({
+                    client,
+                    task,
+                    assignment,
+                    workerKey,
+                    leaseToken,
+                    result: agentResult ?? buildSupervisorFailureRunResult(setupError ?? 'worker_setup_failed'),
+                    status,
+                    resolvedRuntimeModel,
+                    reasoningEffort,
+                    providerAccountLabel,
+                    availableSkillPaths,
+                    observedSkillPaths: [...observedSkillPaths],
+                    startedAt: agentStartedAt ?? completedAt,
+                    completedAt,
+                });
+                telemetryReported = true;
+            };
+            try {
+                assignment = resolveWorkerClaimTaskAssignment(claim);
+                if (!assignment) {
+                    throw new Error('agent_task_claim_missing_task_assignment');
+                }
+                providerAccountLabel = readProviderAccountLabel(assignment.target);
+                const codexModel = assignment.agent === 'CODEX' ? resolveCodexModel(assignment.model) : null;
+                const claudeModel = assignment.agent === 'CLAUDE_CODE' ? resolveClaudeModel(assignment.model) : null;
+                resolvedRuntimeModel = codexModel?.model ?? claudeModel?.model ?? assignment.model;
+                reasoningEffort = codexModel?.reasoningEffort ?? claudeModel?.effort ?? null;
+                const taskContext = buildWorkerTaskContext(claim, assignment);
+                workspaceDir = workerTaskWorkspaceDirFromAssignment(assignment);
+                await (0, promises_1.rm)(workspaceDir, { recursive: true, force: true });
+                await (0, promises_1.mkdir)(workspaceDir, { recursive: true });
+                const eventDir = node_path_1.default.join(workspaceDir, '.playdrop-task-events');
+                await (0, promises_1.mkdir)(eventDir, { recursive: true });
+                const binDir = await createLocalPlaydropShim(workspaceDir);
+                await stageWorkerTaskContext({
+                    workspaceDir,
+                    env,
+                    devPort,
+                    taskContext,
+                });
+                const handleEventDrainFailure = (error) => {
+                    const classification = classifyWorkerEventDrainError(error);
+                    if (classification === 'session_expired') {
+                        handleSessionExpiry();
+                        return;
+                    }
+                    if (classification === 'lease_invalid') {
+                        fenced = true;
+                        activeTerminators.get(task.id)?.();
+                        return;
+                    }
+                    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 }));
+                    return eventDrainPromise;
+                };
+                const appendObservedSkillPathsFromTranscript = (chunks) => {
+                    if (availableSkillPaths.length <= 0) {
+                        return;
+                    }
+                    for (const chunk of chunks) {
+                        for (const observedPath of collectObservedPlaydropSkillPaths(chunk.content, availableSkillPaths)) {
+                            observedSkillPaths.add(observedPath);
+                        }
+                    }
+                };
+                const appendTranscriptChunks = async (chunks) => {
+                    appendObservedSkillPathsFromTranscript(chunks);
+                    await appendWorkerTranscriptChunks({ client, taskId: task.id, workerKey, leaseToken, chunks });
+                };
+                await client.workerCreateAgentTaskEvent(task.id, {
+                    workerKey,
+                    leaseToken,
+                    kind: 'progress',
+                    phase: 'setup',
+                    message: 'Preparing worker workspace',
+                    pct: 2,
+                });
+                availableSkillPaths = normalizeTelemetrySkillPaths(await stagePlaydropPluginReferences({ workspaceDir, pluginRoot: playdropPluginRoot, kind: task.kind }));
+                await client.workerCreateAgentTaskEvent(task.id, {
+                    workerKey,
+                    leaseToken,
+                    kind: 'progress',
+                    phase: 'setup',
+                    message: 'Staged PlayDrop plugin references',
+                    pct: 3,
+                });
+                if (assignment.workspace.files.length > 0) {
+                    await client.workerCreateAgentTaskEvent(task.id, {
+                        workerKey,
+                        leaseToken,
+                        kind: 'progress',
+                        phase: 'setup',
+                        message: `Staging ${assignment.workspace.files.length} server-provided workspace file${assignment.workspace.files.length === 1 ? '' : 's'}`,
+                        pct: 3,
+                    });
+                    await stageAssignmentWorkspaceFiles(workspaceDir, assignment.workspace.files);
+                }
+                heartbeatTimer = setInterval(() => {
+                    client.workerHeartbeatAgentTask(task.id, { workerKey, leaseToken })
+                        .then((heartbeat) => {
+                        if (heartbeat.action === 'abort') {
+                            fenced = true;
+                            activeTerminators.get(task.id)?.();
+                        }
+                    })
+                        .catch((error) => {
+                        if (isWorkerAuthFailureError(error)) {
+                            handleSessionExpiry();
+                            return;
+                        }
+                        if (isLeaseInvalidError(error)) {
+                            fenced = true;
+                            activeTerminators.get(task.id)?.();
+                            return;
+                        }
+                        console.error(`Agent task heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                }, HEARTBEAT_INTERVAL_MS);
+                eventDrainTimer = setInterval(() => {
+                    queueEventDrain().catch((error) => {
+                        handleEventDrainFailure(error);
+                    });
+                }, 1000);
+                const prompt = assignment.prompt;
+                if (task.kind === 'GAME_UPDATE') {
+                    const baseSourcePayload = assignment.inputs.baseSource;
+                    const baseSource = resolveWorkerBaseSource(baseSourcePayload);
+                    await client.workerCreateAgentTaskEvent(task.id, {
+                        workerKey,
+                        leaseToken,
+                        kind: 'progress',
+                        phase: 'setup',
+                        message: `Staging base source ${baseSource.appName} version ${baseSource.version} into the workspace`,
+                        pct: 4,
+                    });
+                    await stageWorkerBaseAppSource({
+                        client,
+                        workspaceDir,
+                        creatorUsername: baseSourcePayload.creatorUsername,
+                        baseApp: baseSource,
+                    });
+                }
+                else if (task.kind === 'NEW_GAME') {
+                    if (assignment.inputs.baseSource !== null) {
+                        throw new Error('agent_task_assignment_unexpected_base_source');
+                    }
+                }
+                else if (task.kind === 'GAME_REVIEW') {
+                    if (assignment.inputs.baseSource !== null) {
+                        throw new Error('agent_task_assignment_unexpected_base_source');
+                    }
+                    if (!assignment.inputs.reviewTarget) {
+                        throw new Error('agent_task_assignment_review_target_missing');
+                    }
+                }
+                else {
+                    throw new Error(`unsupported_agent_task_kind:${task.kind}`);
+                }
+                if (shuttingDown) {
+                    throw new Error('worker_shutdown');
+                }
+                agentStartedAt = new Date();
+                agentResult = assignment.agent === 'CODEX'
+                    ? await runCodex({
+                        workspaceDir,
+                        binDir,
+                        eventDir,
+                        prompt,
+                        envName: env,
+                        taskId: task.id,
+                        attempt: taskContext.attempt,
+                        devPort,
+                        codexModel: codexModel ?? resolveCodexModel(assignment.model),
+                        onTranscriptChunks: async (chunks) => {
+                            await appendTranscriptChunks(chunks);
+                        },
+                        onChild: (controls) => {
+                            activeTerminators.set(task.id, controls.terminate);
+                        },
+                    })
+                    : await runClaude({
+                        workspaceDir,
+                        binDir,
+                        eventDir,
+                        prompt,
+                        envName: env,
+                        taskId: task.id,
+                        attempt: taskContext.attempt,
+                        devPort,
+                        claudeModel: claudeModel ?? resolveClaudeModel(assignment.model),
+                        playdropPluginRoot,
+                        onTranscriptChunks: async (chunks) => {
+                            await appendTranscriptChunks(chunks);
+                        },
+                        onChild: (controls) => {
+                            activeTerminators.set(task.id, controls.terminate);
+                        },
+                    });
+                agentCompletedAt = new Date();
+                await queueEventDrain().catch((error) => {
+                    handleEventDrainFailure(error);
+                });
+                const completedAgentResult = agentResult;
+                const agentRunResult = buildAgentRunResult(completedAgentResult);
+                if (fenced) {
+                    const refreshed = await fetchTaskDetail(client, target, task.id).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}.`);
+                        await reportTelemetry(refreshed.task.status);
+                    }
+                    else {
+                        console.error(`Agent task ${task.id} was aborted by the server; cleaning up without reporting failure.`);
+                    }
+                }
+                else if (sessionExpired) {
+                    // Best effort: the session is already invalid, so this fail call
+                    // likely 401s too; failTaskWithRetry logs loudly after the retry.
+                    await failTaskWithRetry(client, task.id, {
+                        workerKey,
+                        leaseToken,
+                        error: 'worker_session_expired',
+                        result: agentRunResult,
+                    });
+                }
+                else if (shuttingDown) {
+                    await failTaskWithRetry(client, task.id, {
+                        workerKey,
+                        leaseToken,
+                        error: 'worker_shutdown',
+                        result: agentRunResult,
+                    });
+                    await reportTelemetry('FAILED');
+                }
+                else if (completedAgentResult.timedOut || completedAgentResult.exitCode !== 0 || completedAgentResult.signal) {
+                    const refreshed = await fetchTaskDetail(client, target, task.id);
+                    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 (hasAgentTaskUploadedArtifact(refreshed.task)) {
+                        retainWorkspace = true;
+                        console.error(`Agent task ${task.id} already uploaded an artifact but exited before task completion. Leaving it for manual completion repair.`);
+                        await client.workerCreateAgentTaskEvent(task.id, {
+                            workerKey,
+                            leaseToken,
+                            kind: 'progress',
+                            phase: 'upload',
+                            message: 'Agent exited after upload before task done; manual completion repair required.',
+                        });
+                        await reportTelemetry('RUNNING');
+                    }
+                    else {
+                        retainWorkspace = true;
+                        const failureCode = buildAgentFailureCode(assignment.agent, completedAgentResult);
+                        await client.workerCreateAgentTaskEvent(task.id, {
+                            workerKey,
+                            leaseToken,
+                            kind: 'system',
+                            phase: 'failed',
+                            message: describeAgentFailureForEvent(failureCode),
+                            pct: null,
+                            payload: { error: failureCode },
+                        });
+                        await failTaskWithRetry(client, task.id, {
+                            workerKey,
+                            leaseToken,
+                            error: failureCode,
+                            result: agentRunResult,
+                        });
+                        await reportTelemetry('FAILED');
+                    }
+                }
+                else {
+                    const refreshed = await fetchTaskDetail(client, target, task.id);
+                    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 (hasAgentTaskUploadedArtifact(refreshed.task)) {
+                        retainWorkspace = true;
+                        console.error(`Agent task ${task.id} already uploaded an artifact but exited before task completion. Leaving it for manual completion repair.`);
+                        await client.workerCreateAgentTaskEvent(task.id, {
+                            workerKey,
+                            leaseToken,
+                            kind: 'progress',
+                            phase: 'upload',
+                            message: 'Agent exited after upload before task done; manual completion repair required.',
+                        });
+                        await reportTelemetry('RUNNING');
+                    }
+                    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.',
+                            });
+                        }
+                        await client.workerCreateAgentTaskEvent(task.id, {
+                            workerKey,
+                            leaseToken,
+                            kind: 'progress',
+                            phase: 'failed',
+                            message: 'Agent exited before running playdrop task done',
+                        });
+                        retainWorkspace = true;
+                        await failTaskWithRetry(client, task.id, {
+                            workerKey,
+                            leaseToken,
+                            error: 'agent_exited_without_task_done',
+                            result: agentRunResult,
+                        });
+                        await reportTelemetry('FAILED');
+                    }
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (isAgentTaskNotRunningError(error)) {
+                    const refreshed = await fetchTaskDetail(client, target, task.id).catch(() => null);
+                    retainWorkspace = refreshed?.task.status === 'FAILED';
+                    console.error(`Agent task ${task.id} was already finalized${refreshed ? ` as ${refreshed.task.status}` : ''}.`);
+                }
+                else {
+                    retainWorkspace = true;
+                    console.error(`Agent task ${task.id} failed in the worker: ${message}`);
+                }
+                if (!fenced && !isAgentTaskNotRunningError(error)) {
+                    try {
+                        await failTaskWithRetry(client, task.id, {
+                            workerKey,
+                            leaseToken,
+                            error: normalizeWorkerFailureErrorCode(message),
+                            result: { workerError: message },
+                        });
+                    }
+                    finally {
+                        if (!telemetryReported) {
+                            try {
+                                await reportTelemetry('FAILED', message);
+                            }
+                            catch (telemetryError) {
+                                console.error(`Agent task telemetry failed: ${telemetryError instanceof Error ? telemetryError.message : String(telemetryError)}`);
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                }
+                if (eventDrainTimer) {
+                    clearInterval(eventDrainTimer);
+                }
+                activeTerminators.delete(task.id);
+                if (retainWorkspace && (0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_RETAIN_FAILED_WORKSPACE', true)) {
+                    console.error(`Retained failed task workspace for debugging: ${workspaceDir ?? '(not created)'}`);
+                }
+                else if (workspaceDir) {
+                    await (0, promises_1.rm)(workspaceDir, { recursive: true, force: true });
+                }
+            }
+            if (sessionExpired) {
+                throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+            }
+        };
+        try {
+            let claimBackoffMs = CLAIM_BACKOFF_BASE_MS;
+            while (!shuttingDown) {
+                if (fatalTaskError) {
+                    throw fatalTaskError;
+                }
+                if (sessionExpired) {
+                    throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+                }
+                if (activeTaskRuns.size >= maxParallelTasks) {
+                    await sleep(DEFAULT_POLL_INTERVAL_MS);
+                    continue;
+                }
+                const devPort = allocateWorkerDevPort({
+                    activePorts: activeDevPorts,
+                    basePort: workerDevPortBase,
+                    maxParallelTasks,
+                });
+                let claim;
+                try {
+                    claim = await client.workerClaimAgentTask(buildWorkerClaimBody({
+                        workerKey,
+                        capabilities,
+                        runningTaskCount: activeTaskRuns.size,
+                    }));
+                    claimBackoffMs = CLAIM_BACKOFF_BASE_MS;
+                }
+                catch (error) {
+                    // Auth (401) and forbidden (403) claim errors stop the worker; only
+                    // transient errors reach the backoff below.
+                    assertWorkerClaimErrorRetryable(error);
+                    console.error(`Agent task claim failed: ${error instanceof Error ? error.message : String(error)}`);
+                    await sleep(claimBackoffDelayMs(claimBackoffMs));
+                    claimBackoffMs = nextClaimBackoffMs(claimBackoffMs);
+                    continue;
+                }
+                const task = claim.task;
+                if (!task) {
+                    if (shuttingDown) {
+                        break;
+                    }
+                    if (options.once) {
+                        return;
+                    }
+                    await sleep(DEFAULT_POLL_INTERVAL_MS);
+                    continue;
+                }
+                activeTaskIds.add(task.id);
+                activeDevPorts.add(devPort);
+                const taskRun = runClaimedTask(claim, devPort)
+                    .catch((error) => {
+                    recordFatalTaskError(error);
+                })
+                    .finally(() => {
+                    activeTaskRuns.delete(task.id);
+                    activeTaskIds.delete(task.id);
+                    activeDevPorts.delete(devPort);
+                });
+                activeTaskRuns.set(task.id, taskRun);
+                if (options.once) {
+                    await taskRun;
+                    if (fatalTaskError) {
+                        throw fatalTaskError;
+                    }
+                    return;
+                }
+            }
+            if (activeTaskRuns.size > 0) {
+                await Promise.allSettled(Array.from(activeTaskRuns.values()));
+            }
+            if (fatalTaskError) {
+                throw fatalTaskError;
+            }
+            if (sessionExpired) {
+                throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
+            }
+            if (shuttingDown) {
+                await sendWorkerHealthAlertSafely({
+                    state: 'stopped',
+                    env,
+                    workerName,
+                    taskId: firstActiveTaskId(),
+                    detail: shutdownSignal,
+                });
+                node_process_1.default.exit(shutdownSignal === 'SIGINT' ? 130 : 143);
+            }
+        }
+        catch (error) {
+            crashed = true;
+            await sendWorkerHealthAlertSafely({
+                state: 'crashed',
+                env,
+                workerName,
+                taskId: firstActiveTaskId(),
+                detail: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        finally {
+            if (presenceTimer) {
+                clearInterval(presenceTimer);
+            }
+            node_process_1.default.off('SIGINT', signalHandler);
+            node_process_1.default.off('SIGTERM', signalHandler);
+            if (!crashed) {
+                await sendWorkerHealthAlertSafely({
+                    state: 'stopped',
+                    env,
+                    workerName,
+                    taskId: firstActiveTaskId(),
+                });
+            }
+        }
+    }, { env: options.env });
+}
+async function reportTask(options) {
+    const message = options.message?.trim();
+    if (!message) {
+        (0, messages_1.printErrorWithHelp)('Task report requires a message.', ['Example: playdrop task report --phase build --pct 25 -m "Building first loop"'], { command: 'task report' });
+        node_process_1.default.exitCode = 1;
+        return;
+    }
+    const pct = parseOptionalPct(options.pct);
+    const kind = normalizeTaskEventKind(options.kind);
+    const phase = options.phase?.trim() || null;
+    if (resolveWorkerEventQueueDir()) {
+        enqueueWorkerContextEvent({ kind, phase, message, pct });
+        (0, output_1.printSuccess)('Task progress queued.');
+        return;
+    }
+    resolveWorkerTaskStateForWrite();
+}
+async function reportCatalogueTask(options) {
+    const message = options.message?.trim();
+    if (!message) {
+        (0, messages_1.printErrorWithHelp)('Task catalogue report requires a message.', ['Example: playdrop task report-catalogue --file catalogue.json -m "Draft catalogue ready"'], { command: 'task report-catalogue' });
+        node_process_1.default.exitCode = 1;
+        return;
+    }
+    const file = options.file?.trim();
+    if (!file) {
+        (0, messages_1.printErrorWithHelp)('Task catalogue report requires a catalogue file.', ['Example: playdrop task report-catalogue --file catalogue.json -m "Draft catalogue ready"'], { command: 'task report-catalogue' });
+        node_process_1.default.exitCode = 1;
+        return;
+    }
+    const cataloguePath = node_path_1.default.isAbsolute(file) ? file : node_path_1.default.resolve(node_process_1.default.cwd(), file);
+    const payload = buildCataloguePreviewPayload(cataloguePath, node_process_1.default.cwd());
+    if (resolveWorkerEventQueueDir()) {
+        enqueueWorkerContextEvent({
+            kind: 'catalogue_preview',
+            phase: 'catalogue',
+            message,
+            payload,
+        });
+        (0, output_1.printSuccess)('Task catalogue preview queued.');
+        return;
+    }
+    resolveWorkerTaskStateForWrite();
+}
+async function resolveTaskCommandContext(command, optionsEnv, taskContext) {
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)(command, command, {
+        env: optionsEnv ?? taskContext.env,
+        workspacePath: node_process_1.default.cwd(),
+    });
+    if (!ctx) {
+        return null;
+    }
+    const me = await ctx.client.me();
+    if (!me.user) {
+        throw new Error('task_context_user_missing');
+    }
+    return { ...ctx, user: me.user };
+}
+async function uploadTask(options = {}) {
+    const taskContext = readTaskContextFile();
+    if (taskContext.kind === 'GAME_REVIEW') {
+        throw new Error('task_upload_not_allowed_for_game_review');
+    }
+    const workspaceDir = resolveTaskWorkspaceDir();
+    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;
+    }
+    const ctx = await resolveTaskCommandContext('task upload', options.env, taskContext);
+    if (!ctx) {
+        return;
+    }
+    const projectDir = discoverWorkerProjectRoot(node_process_1.default.cwd());
+    const published = await (0, upload_1.publishWorkerAppProject)({
+        client: ctx.client,
+        taskId: taskContext.taskId,
+        kind: taskContext.kind,
+        expectedAppName: taskContext.outputAppName ?? undefined,
+        playdropAssetRequirement: resolvePlaydropAssetRequirementFromTaskRequest(taskContext.creatorRequest),
+        creatorRequest: taskContext.creatorRequest,
+        projectDir,
+        creatorUsername: taskContext.creatorUsername,
+        apiBase: ctx.envConfig.apiBase,
+        webBase: ctx.envConfig.webBase ?? null,
+        token: ctx.token,
+        user: ctx.user,
+    });
+    const result = {
+        taskId: taskContext.taskId,
+        appId: published.appId,
+        appVersionId: published.appVersionId,
+        appName: published.appName,
+        version: published.version,
+        versionNodeId: published.versionNodeId,
+        creatorUsername: published.creatorUsername,
+    };
+    await (0, promises_1.writeFile)(workerTaskUploadResultPath(workspaceDir), JSON.stringify(result, null, 2), 'utf8');
+    for (const warning of published.warnings) {
+        console.error(`Upload warning: ${warning}`);
+    }
+    (0, output_1.printSuccess)(`Uploaded ${published.creatorUsername}/${published.appName} version ${published.version}. Run "playdrop task done" to close the task.`);
+}
+async function completeTask(options) {
+    const taskContext = readTaskContextFile();
+    if (taskContext.kind === 'GAME_REVIEW') {
+        throw new Error('task_done_not_allowed_for_game_review');
+    }
+    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) {
+        throw new Error('task_done_missing_upload_result');
+    }
+    if (uploadResult.taskId !== taskContext.taskId) {
+        throw new Error('task_done_upload_result_task_mismatch');
+    }
+    await ctx.client.workerCompleteAgentTask(taskContext.taskId, {
+        taskToken: taskContext.taskToken,
+        appId,
+        appVersionId,
+        result: {
+            appId: uploadResult.appId,
+            appVersionId: uploadResult.appVersionId,
+            version: uploadResult.version,
+            appName: uploadResult.appName,
+            versionNodeId: uploadResult.versionNodeId,
+            creatorUsername: uploadResult.creatorUsername,
+            completedBy: 'agent',
+        },
+    });
+    (0, output_1.printSuccess)('Task marked done.');
+}
+function normalizeReviewSubmitState(value) {
+    const normalized = typeof value === 'string' ? value.trim().toUpperCase() : '';
+    if (normalized !== 'PASSED'
+        && normalized !== 'GOOD'
+        && normalized !== 'EXCELLENT'
+        && normalized !== 'LOW_QUALITY'
+        && normalized !== 'FAILED'
+        && normalized !== 'ERROR') {
+        throw new Error('invalid_review_state');
+    }
+    return normalized;
+}
+function readRequiredTextFile(filePath, code) {
+    const normalizedPath = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalizedPath) {
+        throw new Error(code);
+    }
+    const resolved = node_path_1.default.resolve(normalizedPath);
+    if (!(0, node_fs_1.existsSync)(resolved)) {
+        throw new Error(code);
+    }
+    const content = (0, node_fs_1.readFileSync)(resolved, 'utf8').trim();
+    if (!content) {
+        throw new Error(code);
+    }
+    return content;
+}
+function readOptionalTextFile(filePath) {
+    const normalizedPath = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalizedPath) {
+        return null;
+    }
+    const resolved = node_path_1.default.resolve(normalizedPath);
+    if (!(0, node_fs_1.existsSync)(resolved)) {
+        throw new Error('invalid_creator_feedback_file');
+    }
+    const content = (0, node_fs_1.readFileSync)(resolved, 'utf8').trim();
+    return content || null;
+}
+function contentTypeForEvidenceFile(fileName) {
+    const extension = node_path_1.default.extname(fileName).toLowerCase();
+    if (extension === '.png')
+        return 'image/png';
+    if (extension === '.jpg' || extension === '.jpeg')
+        return 'image/jpeg';
+    if (extension === '.webp')
+        return 'image/webp';
+    return 'application/octet-stream';
+}
+function readReviewEvidenceFiles(evidenceDir) {
+    const normalizedDir = typeof evidenceDir === 'string' ? evidenceDir.trim() : '';
+    if (!normalizedDir) {
+        throw new Error('invalid_review_evidence_dir');
+    }
+    const resolvedDir = node_path_1.default.resolve(normalizedDir);
+    if (!(0, node_fs_1.existsSync)(resolvedDir)) {
+        throw new Error('invalid_review_evidence_dir');
+    }
+    const existingFiles = new Set((0, node_fs_1.readdirSync)(resolvedDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name));
+    const files = review_1.REQUIRED_REVIEW_EVIDENCE_FILES.filter((fileName) => existingFiles.has(fileName));
+    if (files.length !== review_1.REQUIRED_REVIEW_EVIDENCE_FILES.length) {
+        const missing = review_1.REQUIRED_REVIEW_EVIDENCE_FILES.filter((fileName) => !existingFiles.has(fileName));
+        throw new Error(`missing_review_evidence:${missing.join(',')}`);
+    }
+    return files.map((fileName) => {
+        const filePath = node_path_1.default.join(resolvedDir, fileName);
+        const buffer = (0, node_fs_1.readFileSync)(filePath);
+        if (buffer.length <= 0 || buffer.length > 10 * 1024 * 1024) {
+            throw new Error('invalid_review_evidence_size');
+        }
+        return {
+            name: fileName,
+            contentType: contentTypeForEvidenceFile(fileName),
+            contentBase64: buffer.toString('base64'),
+        };
+    });
+}
+function resolveReviewFilePath(filePath, code) {
+    const normalizedPath = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalizedPath) {
+        throw new Error(code);
+    }
+    const resolved = node_path_1.default.resolve(normalizedPath);
+    if (!(0, node_fs_1.existsSync)(resolved)) {
+        throw new Error(code);
+    }
+    return resolved;
+}
+function resolveReviewEvidenceDir(evidenceDir) {
+    const normalizedDir = typeof evidenceDir === 'string' ? evidenceDir.trim() : '';
+    if (!normalizedDir) {
+        throw new Error('invalid_review_evidence_dir');
+    }
+    const resolved = node_path_1.default.resolve(normalizedDir);
+    if (!(0, node_fs_1.existsSync)(resolved)) {
+        throw new Error('invalid_review_evidence_dir');
+    }
+    return resolved;
+}
+async function submitReviewTask(options) {
+    const taskContext = readTaskContextFile();
+    if (taskContext.kind !== 'GAME_REVIEW') {
+        throw new Error('task_submit_review_requires_game_review');
+    }
+    const state = normalizeReviewSubmitState(options.state);
+    const reviewMessageFile = resolveReviewFilePath(options.messageFile, 'invalid_review_message_file');
+    const creatorFeedbackFile = state === 'ERROR'
+        ? null
+        : resolveReviewFilePath(options.creatorFeedbackFile, 'invalid_creator_feedback_file');
+    const evidenceDir = resolveReviewEvidenceDir(options.evidenceDir);
+    const reviewMessage = readRequiredTextFile(reviewMessageFile, 'invalid_review_message_file');
+    const creatorFeedback = state === 'ERROR'
+        ? null
+        : readOptionalTextFile(creatorFeedbackFile ?? undefined);
+    await (0, review_1.validateGameReviewResult)({
+        reviewState: state,
+        reviewMessage,
+        creatorFeedback: creatorFeedback ?? '',
+        evidenceDir,
+    });
+    const evidenceFiles = readReviewEvidenceFiles(evidenceDir);
+    const ctx = await resolveTaskCommandContext('task submit-review', options.env, taskContext);
+    if (!ctx) {
+        throw new Error('task_submit_review_auth_required');
+    }
+    await ctx.client.workerSubmitAgentTaskReview(taskContext.taskId, {
+        taskToken: taskContext.taskToken,
+        appVersionId: taskContext.reviewAppVersionId ?? 0,
+        reviewState: state,
+        reviewMessage,
+        creatorFeedback,
+        evidenceFiles,
+    });
+    (0, output_1.printSuccess)('Review submitted.');
+}
+async function failTask(options) {
+    const message = options.message?.trim();
+    if (!message) {
+        (0, messages_1.printErrorWithHelp)('Task fail requires a message.', ['Example: playdrop task fail -m "Build failed"'], { command: 'task fail' });
+        node_process_1.default.exitCode = 1;
+        return;
+    }
+    const taskContext = readTaskContextFile();
+    const ctx = await resolveTaskCommandContext('task fail', options.env, taskContext);
+    if (!ctx) {
+        return;
+    }
+    await ctx.client.workerFailAgentTask(taskContext.taskId, {
+        taskToken: taskContext.taskToken,
+        error: message,
+        result: { failedBy: 'agent' },
+    });
+    (0, output_1.printSuccess)('Task marked failed.');
+}