@playdrop/playdrop-cli 0.12.32 → 0.12.34

package/dist/commands/worker.js

@@ -7,7 +7,7 @@ exports.WORKER_TASK_WORKSPACE_RETENTION = exports.WORKER_CONTEXT_COMMAND_NOT_ALL
 exports.allocateWorkerDevPort = allocateWorkerDevPort;
 exports.isWorkerContextCommandAllowed = isWorkerContextCommandAllowed;
 exports.resolveWorkerExecutionTargetFromRole = resolveWorkerExecutionTargetFromRole;
-exports.resolveWorkerClaimTaskAssignment = resolveWorkerClaimTaskAssignment;
+exports.normalizeWorkerTaskAssignmentV2 = normalizeWorkerTaskAssignmentV2;
 exports.nextClaimBackoffMs = nextClaimBackoffMs;
 exports.claimBackoffDelayMs = claimBackoffDelayMs;
 exports.resolveWorkerHomeDir = resolveWorkerHomeDir;
@@ -16,9 +16,7 @@ exports.hasAgentTaskUploadedArtifact = hasAgentTaskUploadedArtifact;
 exports.appendWorkerTranscriptChunks = appendWorkerTranscriptChunks;
 exports.readTaskNextStepsFile = readTaskNextStepsFile;
 exports.assertTaskUploadResultMatchesContext = assertTaskUploadResultMatchesContext;
-exports.stageAssignmentWorkspaceFiles = stageAssignmentWorkspaceFiles;
-exports.stagePlaydropPluginReferences = stagePlaydropPluginReferences;
-exports.stageCodexTaskSkills = stageCodexTaskSkills;
+exports.stageAssignmentWorkspaceV2 = stageAssignmentWorkspaceV2;
 exports.assertAssignmentPluginBundleExtractionBounds = assertAssignmentPluginBundleExtractionBounds;
 exports.stageAssignmentPluginBundle = stageAssignmentPluginBundle;
 exports.resolveDevPluginWorkingTree = resolveDevPluginWorkingTree;
@@ -35,12 +33,9 @@ exports.resolvePlaywrightBrowsersPathFromExecutable = resolvePlaywrightBrowsersP
 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.removeStaleWorkerControlFilesFromBaseSource = removeStaleWorkerControlFilesFromBaseSource;
+exports.removeStaleWorkerControlFiles = removeStaleWorkerControlFiles;
 exports.resolveCodexModel = resolveCodexModel;
 exports.resolveClaudeModel = resolveClaudeModel;
 exports.prepareCodexRunHomes = prepareCodexRunHomes;
@@ -76,6 +71,7 @@ exports.instrumentTaskChromeTitleMatchers = instrumentTaskChromeTitleMatchers;
 exports.enforceInstrumentBrowserHygiene = enforceInstrumentBrowserHygiene;
 exports.startWorker = startWorker;
 exports.reportTask = reportTask;
+exports.showTaskContext = showTaskContext;
 exports.reportCatalogueTask = reportCatalogueTask;
 exports.uploadTask = uploadTask;
 exports.claimSlugTask = claimSlugTask;
@@ -97,6 +93,7 @@ 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_util_1 = require("node:util");
+const apiClient_1 = require("../apiClient");
 const clientInfo_1 = require("../clientInfo");
 const commandContext_1 = require("../commandContext");
 const config_1 = require("../config");
@@ -136,15 +133,13 @@ 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_WRAPPER_CONTRACT_VERSION = 1;
+const WORKER_WRAPPER_CONTRACT_VERSION = 2;
 const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'REMIX_GAME', 'GAME_UPDATE', 'GAME_REVIEW', 'GAME_EVAL'];
-const PLAYDROP_PLUGIN_MANIFEST_REQUIRED_STARTUP_KINDS = WORKER_SUPPORTED_KINDS;
 const requireFromWorker = (0, node_module_1.createRequire)(__filename);
-const STAGED_PLAYDROP_PLUGIN_ROOT = '.playdrop/plugin';
-const STAGED_CODEX_SKILL_ROOT = '.agents/skills';
-const PLAYDROP_PLUGIN_STAGING_MANIFEST_PATH = 'playdrop-worker-staging.json';
+const AGENT_BUNDLE_MANIFEST_PATH = 'agent-bundle.json';
 const ASSIGNMENT_PLUGIN_BUNDLE_MAX_FILES = 1000;
 const ASSIGNMENT_PLUGIN_BUNDLE_MAX_UNCOMPRESSED_BYTES = 20 * 1024 * 1024;
+const ASSIGNMENT_WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES = 100 * 1024 * 1024;
 const ZIP_CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
 const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
 const ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES = 22;
@@ -152,6 +147,7 @@ const ZIP_MAX_COMMENT_BYTES = 0xffff;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 exports.WORKER_SESSION_EXPIRED_MESSAGE = 'worker session expired: run "playdrop auth login" and start the worker again';
 const WORKER_CONTEXT_ALLOWED_COMMANDS = [
+    ['task', 'context'],
     ['task', 'report'],
     ['task', 'report-catalogue'],
     ['task', 'claim-slug'],
@@ -300,116 +296,162 @@ function normalizeAssignmentAgent(value) {
     }
     return value;
 }
-function normalizeAssignmentKind(value, task) {
-    if (value !== 'NEW_GAME' && value !== 'REMIX_GAME' && value !== 'GAME_UPDATE' && value !== 'GAME_REVIEW' && value !== 'GAME_EVAL') {
-        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;
+function normalizeAssignmentContent(input) {
+    const relativePath = normalizeAssignmentWorkspaceRelativePath(input.path);
+    const contentBase64 = typeof input.contentBase64 === 'string' ? input.contentBase64.trim() : '';
+    const sha256 = typeof input.sha256 === 'string' ? input.sha256.trim() : '';
+    const sizeBytes = Number(input.sizeBytes);
+    if (!contentBase64 || !/^[A-Za-z0-9+/]+={0,2}$/.test(contentBase64)) {
+        throw new Error(`${input.code}_content_invalid`);
     }
-    const assignment = claim.taskAssignment;
-    if (!assignment || typeof assignment !== 'object') {
-        throw new Error('agent_task_claim_missing_task_assignment');
+    if (!/^[a-f0-9]{64}$/.test(sha256) || !Number.isInteger(sizeBytes) || sizeBytes <= 0) {
+        throw new Error(`${input.code}_metadata_invalid`);
     }
-    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 buffer = Buffer.from(contentBase64, 'base64');
+    if (buffer.length !== sizeBytes) {
+        throw new Error(`${input.code}_size_mismatch`);
     }
-    const taskToken = typeof assignment.taskToken === 'string' ? assignment.taskToken.trim() : '';
-    if (!taskToken) {
-        throw new Error('agent_task_assignment_token_missing');
+    if ((0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex') !== sha256) {
+        throw new Error(`${input.code}_sha_mismatch`);
     }
-    const model = typeof assignment.model === 'string' ? assignment.model.trim() : '';
-    if (!model) {
-        throw new Error('agent_task_assignment_model_missing');
-    }
-    const reasoningEffort = assignment.reasoningEffort === null || assignment.reasoningEffort === undefined
-        ? null
-        : typeof assignment.reasoningEffort === 'string'
-            ? assignment.reasoningEffort.trim()
-            : '';
-    if (reasoningEffort !== null && (!reasoningEffort || reasoningEffort.length > 40 || /\s/.test(reasoningEffort))) {
-        throw new Error('invalid_agent_task_reasoning_effort');
+    return { path: relativePath, contentBase64, sha256, sizeBytes, buffer };
+}
+function normalizeWorkerTaskAssignmentV2(claim) {
+    if (claim.protocolVersion !== 2) {
+        throw new Error('agent_task_claim_protocol_version_mismatch');
     }
-    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');
+    if (claim.action !== 'run') {
+        return null;
     }
-    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 assignment = claim.assignment;
+    const taskId = parsePositiveInteger(assignment.task.id, 'agent_task_assignment_task_id_missing');
+    const taskToken = typeof assignment.task.token === 'string' ? assignment.task.token.trim() : '';
+    const taskType = typeof assignment.task.type === 'string' ? assignment.task.type.trim() : '';
+    const attempt = parsePositiveInteger(assignment.task.attempt, 'agent_task_assignment_attempt_missing');
+    const prompt = typeof assignment.request.prompt === 'string' ? assignment.request.prompt : '';
+    const model = typeof assignment.agent.model === 'string' ? assignment.agent.model.trim() : '';
+    if (!taskToken || !taskType || !prompt.trim() || !model) {
+        throw new Error('agent_task_assignment_invalid');
+    }
+    const workspacePaths = new Set();
+    const files = assignment.workspace.files.map((file) => {
+        const normalized = normalizeAssignmentContent({
+            path: file.path,
+            contentBase64: file.contentBase64,
+            sha256: file.sha256,
+            sizeBytes: file.sizeBytes,
+            code: 'agent_task_assignment_workspace_file',
+        });
+        const contentType = typeof file.contentType === 'string' ? file.contentType.trim() : '';
+        if (!contentType) {
+            throw new Error('agent_task_assignment_workspace_file_content_type_missing');
+        }
+        if (workspacePaths.has(normalized.path)) {
+            throw new Error('agent_task_assignment_workspace_path_duplicate');
+        }
+        workspacePaths.add(normalized.path);
+        return {
+            path: normalized.path,
+            sha256: normalized.sha256,
+            sizeBytes: normalized.sizeBytes,
+            contentType,
+            contentBase64: normalized.contentBase64,
+        };
+    });
+    const archives = assignment.workspace.archives.map((archive) => {
+        if (archive.format !== 'zip') {
+            throw new Error('agent_task_assignment_workspace_archive_format_invalid');
+        }
+        const normalized = normalizeAssignmentContent({
+            path: archive.path,
+            contentBase64: archive.contentBase64,
+            sha256: archive.sha256,
+            sizeBytes: archive.sizeBytes,
+            code: 'agent_task_assignment_workspace_archive',
+        });
+        if (workspacePaths.has(normalized.path)) {
+            throw new Error('agent_task_assignment_workspace_path_duplicate');
+        }
+        workspacePaths.add(normalized.path);
+        return {
+            path: normalized.path,
+            format: 'zip',
+            sha256: normalized.sha256,
+            sizeBytes: normalized.sizeBytes,
+            contentBase64: normalized.contentBase64,
+        };
+    });
+    const fileByPath = new Map(files.map((file) => [file.path, file]));
+    const attachmentIds = new Set();
+    const attachments = assignment.request.attachments.map((attachment) => {
+        const id = typeof attachment.id === 'string' ? attachment.id.trim() : '';
+        const attachmentPath = normalizeAssignmentWorkspaceRelativePath(attachment.path);
+        const fileName = typeof attachment.fileName === 'string' ? attachment.fileName.trim() : '';
+        const contentType = typeof attachment.contentType === 'string' ? attachment.contentType.trim() : '';
+        const sha256 = typeof attachment.sha256 === 'string' ? attachment.sha256.trim() : '';
+        const sizeBytes = Number(attachment.sizeBytes);
+        const file = fileByPath.get(attachmentPath);
+        if (!id || attachmentIds.has(id) || !fileName || !contentType || !file) {
+            throw new Error('agent_task_assignment_attachment_invalid');
+        }
+        if (sha256 !== file.sha256 || sizeBytes !== file.sizeBytes || contentType !== file.contentType) {
+            throw new Error('agent_task_assignment_attachment_metadata_mismatch');
+        }
+        attachmentIds.add(id);
+        return {
+            id,
+            path: attachmentPath,
+            fileName,
+            contentType,
+            sizeBytes,
+            sha256,
+            description: typeof attachment.description === 'string' ? attachment.description : null,
+        };
+    });
+    for (const attachment of attachments) {
+        if (!fileByPath.has(attachment.path)) {
+            throw new Error('agent_task_assignment_attachment_file_missing');
+        }
     }
-    const 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 browser = assignment.agent.browser;
+    if (browser !== 'NONE' && browser !== 'CHROME' && browser !== 'PLAYWRIGHT') {
+        throw new Error('agent_task_assignment_browser_invalid');
     }
-    const version = typeof output.version === 'string' ? output.version.trim() : '';
-    if (!version) {
-        throw new Error('agent_task_assignment_output_version_missing');
-    }
-    const pluginBundle = assignment.pluginBundle && typeof assignment.pluginBundle === 'object' && !Array.isArray(assignment.pluginBundle)
-        ? assignment.pluginBundle
-        : null;
-    if (!pluginBundle) {
-        throw new Error('agent_task_assignment_plugin_bundle_missing');
+    const reasoningEffort = assignment.agent.reasoningEffort;
+    if (reasoningEffort !== null && typeof reasoningEffort !== 'string') {
+        throw new Error('agent_task_assignment_reasoning_effort_invalid');
     }
     return {
-        taskId,
-        taskToken,
-        kind: normalizeAssignmentKind(assignment.kind, claim.task),
-        target: normalizeAssignmentTarget(assignment.target),
-        agent: normalizeAssignmentAgent(assignment.agent),
-        model,
-        reasoningEffort,
-        attemptPlan: assignment.attemptPlan ?? null,
-        selectedAttempt: assignment.selectedAttempt ?? null,
+        task: {
+            id: taskId,
+            token: taskToken,
+            type: taskType,
+            executionTarget: normalizeAssignmentTarget(assignment.task.executionTarget),
+            attempt,
+            metadata: assignment.task.metadata,
+        },
         workspace: {
-            folderName: normalizeAssignmentWorkspaceFolder(workspace.folderName),
-            files: normalizeAssignmentWorkspaceFiles(workspace.files),
+            folderName: normalizeAssignmentWorkspaceFolder(assignment.workspace.folderName),
+            archives,
+            files,
         },
-        inputs: {
-            request: {
-                prompt: normalizeAssignmentRequest(inputs.request),
-            },
-            attachments: Array.isArray(inputs.attachments) ? inputs.attachments : [],
-            baseSource: inputs.baseSource ?? null,
-            remixSource: inputs.remixSource ?? null,
-            reviewTarget: inputs.reviewTarget ?? null,
-            evalTarget: inputs.evalTarget ?? null,
-            allowedTemplateKeys: Array.isArray(inputs.allowedTemplateKeys)
-                ? Array.from(new Set(inputs.allowedTemplateKeys.map((value) => (typeof value === 'string' ? value.trim() : '')).filter(Boolean)))
-                : [],
+        plugin: assignment.plugin,
+        request: {
+            prompt,
+            attachments,
         },
-        pluginBundle,
-        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,
+        agent: {
+            runtime: normalizeAssignmentAgent(assignment.agent.runtime),
+            model,
+            reasoningEffort,
+            browser,
         },
-        prompt,
     };
 }
 function nextClaimBackoffMs(currentMs) {
@@ -458,73 +500,55 @@ async function pruneWorkerTaskWorkspaces(incomingWorkspaceDir, retention = expor
     }
     return removed;
 }
-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');
+function buildWorkerTaskContext(input) {
+    const playdrop = input.metadata.playdrop;
+    if (!playdrop || typeof playdrop !== 'object' || Array.isArray(playdrop)) {
+        throw new Error('agent_task_context_playdrop_metadata_missing');
     }
-    if (task.executionTarget !== assignment.target) {
-        throw new Error('agent_task_context_target_mismatch');
+    const metadata = playdrop;
+    const kind = metadata.kind;
+    if (kind !== 'NEW_GAME' && kind !== 'REMIX_GAME' && kind !== 'GAME_UPDATE' && kind !== 'GAME_REVIEW' && kind !== 'GAME_EVAL') {
+        throw new Error('agent_task_context_kind_missing');
     }
-    const creatorUsername = typeof task.creatorUsername === 'string' ? task.creatorUsername.trim() : '';
-    const outputVersion = typeof assignment.output.version === 'string' ? assignment.output.version.trim() : '';
+    const creatorUsername = typeof metadata.creatorUsername === 'string'
+        ? metadata.creatorUsername.trim()
+        : '';
+    const output = metadata.output && typeof metadata.output === 'object' && !Array.isArray(metadata.output)
+        ? metadata.output
+        : null;
+    const outputVersion = typeof output?.version === 'string' ? output.version.trim() : '';
+    const outputAppName = typeof output?.appName === 'string' && output.appName.trim()
+        ? output.appName.trim()
+        : null;
     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()
+    const remixSource = metadata.remixSource && typeof metadata.remixSource === 'object' && !Array.isArray(metadata.remixSource)
+        ? metadata.remixSource
         : null;
-    const reviewTarget = assignment.inputs.reviewTarget && typeof assignment.inputs.reviewTarget === 'object'
-        ? assignment.inputs.reviewTarget
+    const remixSourceRef = typeof remixSource?.ref === 'string' && remixSource.ref.trim()
+        ? remixSource.ref.trim()
         : 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 remixSource = assignment.inputs.remixSource && typeof assignment.inputs.remixSource === 'object'
-        ? assignment.inputs.remixSource
+    const reviewTarget = metadata.reviewTarget && typeof metadata.reviewTarget === 'object' && !Array.isArray(metadata.reviewTarget)
+        ? metadata.reviewTarget
         : null;
-    let remixSourceRef = null;
-    if (assignment.kind === 'REMIX_GAME') {
-        const parsedRemixSourceRef = typeof remixSource?.ref === 'string' ? remixSource.ref.trim() : '';
-        if (!parsedRemixSourceRef) {
-            throw new Error('agent_task_context_remix_source_missing');
-        }
-        remixSourceRef = parsedRemixSourceRef;
-    }
-    const allowedTemplateKeys = Array.isArray(assignment.inputs.allowedTemplateKeys)
-        ? Array.from(new Set(assignment.inputs.allowedTemplateKeys.map((value) => (typeof value === 'string' ? value.trim() : '')).filter(Boolean)))
+    const rawReviewAppVersionId = Number(reviewTarget?.appVersionId);
+    const reviewAppVersionId = Number.isInteger(rawReviewAppVersionId) && rawReviewAppVersionId > 0
+        ? rawReviewAppVersionId
+        : null;
+    const allowedTemplateKeys = Array.isArray(metadata.allowedTemplateKeys)
+        ? metadata.allowedTemplateKeys.filter((value) => typeof value === 'string' && Boolean(value.trim()))
         : [];
-    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,
+        taskId: input.taskId,
+        attempt: input.attempt,
+        taskToken: input.taskToken,
+        taskType: input.taskType,
+        metadata: input.metadata,
+        kind,
         creatorUsername,
-        creatorRequest,
-        target: assignment.target,
+        creatorRequest: input.prompt,
+        target: input.target,
         outputAppName,
         outputVersion,
         remixSourceRef,
@@ -532,12 +556,62 @@ function buildWorkerTaskContext(claim, assignment) {
         reviewAppVersionId,
     };
 }
+function buildWorkerTaskContextV2(assignment) {
+    return buildWorkerTaskContext({
+        taskId: assignment.task.id,
+        attempt: assignment.task.attempt,
+        taskToken: assignment.task.token,
+        taskType: assignment.task.type,
+        metadata: assignment.task.metadata,
+        prompt: assignment.request.prompt,
+        target: assignment.task.executionTarget,
+    });
+}
 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');
 }
+function serializeWorkerTaskContext(taskContext) {
+    const playdrop = taskContext.metadata.playdrop;
+    if (!playdrop || typeof playdrop !== 'object' || Array.isArray(playdrop)) {
+        throw new Error('agent_task_context_playdrop_metadata_missing');
+    }
+    const playdropMetadata = playdrop;
+    const output = playdropMetadata.output;
+    if (!output || typeof output !== 'object' || Array.isArray(output)) {
+        throw new Error('agent_task_context_invalid');
+    }
+    const metadata = {
+        ...taskContext.metadata,
+        playdrop: {
+            ...playdropMetadata,
+            output: {
+                ...output,
+                appName: taskContext.outputAppName,
+            },
+        },
+    };
+    return {
+        protocolVersion: 2,
+        task: {
+            id: taskContext.taskId,
+            attempt: taskContext.attempt,
+            token: taskContext.taskToken,
+            type: taskContext.taskType,
+            executionTarget: taskContext.target,
+            metadata,
+        },
+        request: {
+            prompt: taskContext.creatorRequest,
+        },
+        worker: {
+            devPort: taskContext.devPort,
+            env: taskContext.env,
+        },
+    };
+}
 async function stageWorkerTaskContext(input) {
     const playdropDir = node_path_1.default.join(input.workspaceDir, '.playdrop');
     await (0, promises_1.mkdir)(playdropDir, { recursive: true });
@@ -546,18 +620,10 @@ async function stageWorkerTaskContext(input) {
         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');
+    await (0, promises_1.writeFile)(workerTaskContextPath(input.workspaceDir), JSON.stringify(serializeWorkerTaskContext(taskFile), null, 2), 'utf8');
 }
 async function writeWorkerTaskContextFile(workspaceDir, taskContext) {
-    await (0, promises_1.writeFile)(workerTaskContextPath(workspaceDir), JSON.stringify(taskContext, null, 2), 'utf8');
+    await (0, promises_1.writeFile)(workerTaskContextPath(workspaceDir), JSON.stringify(serializeWorkerTaskContext(taskContext), null, 2), 'utf8');
 }
 function findWorkspaceTaskFile(startDir, basename) {
     let current = node_path_1.default.resolve(startDir);
@@ -576,67 +642,57 @@ function findWorkspaceTaskFile(startDir, basename) {
 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() : '';
-    const remixSourceRef = typeof parsed.remixSourceRef === 'string' && parsed.remixSourceRef.trim()
-        ? parsed.remixSourceRef.trim()
+    const task = parsed.task && typeof parsed.task === 'object' && !Array.isArray(parsed.task)
+        ? parsed.task
         : null;
-    const allowedTemplateKeys = Array.isArray(parsed.allowedTemplateKeys)
-        ? Array.from(new Set(parsed.allowedTemplateKeys.map((value) => (typeof value === 'string' ? value.trim() : '')).filter(Boolean)))
-        : [];
-    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
+    const request = parsed.request && typeof parsed.request === 'object' && !Array.isArray(parsed.request)
+        ? parsed.request
+        : null;
+    const worker = parsed.worker && typeof parsed.worker === 'object' && !Array.isArray(parsed.worker)
+        ? parsed.worker
+        : null;
+    const taskId = Number(task?.id);
+    const attempt = Number(task?.attempt);
+    const taskToken = typeof task?.token === 'string' ? task.token.trim() : '';
+    const taskType = typeof task?.type === 'string' ? task.type.trim() : '';
+    const metadata = task?.metadata && typeof task.metadata === 'object' && !Array.isArray(task.metadata)
+        ? task.metadata
+        : null;
+    const prompt = typeof request?.prompt === 'string' ? request.prompt : '';
+    const env = typeof worker?.env === 'string' ? worker.env.trim() : '';
+    const devPort = typeof worker?.devPort === 'number'
+        ? worker.devPort
+        : Number.parseInt(String(worker?.devPort ?? ''), 10);
+    if (parsed.protocolVersion !== 2
+        || !Number.isInteger(taskId) || taskId <= 0
         || !Number.isInteger(attempt) || attempt <= 0
         || !taskToken
-        || (parsed.kind !== 'NEW_GAME' && parsed.kind !== 'REMIX_GAME' && parsed.kind !== 'GAME_UPDATE' && parsed.kind !== 'GAME_REVIEW' && parsed.kind !== 'GAME_EVAL')
-        || (parsed.target !== 'FIRST_PARTY' && parsed.target !== 'PERSONAL')
-        || !creatorUsername
-        || !creatorRequest
+        || !taskType
+        || !metadata
+        || (task?.executionTarget !== 'FIRST_PARTY' && task?.executionTarget !== 'PERSONAL')
+        || !prompt.trim()
         || !env
-        || !outputVersion
-        || (parsed.kind === 'REMIX_GAME' && !remixSourceRef)
-        || (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,
-        remixSourceRef,
-        allowedTemplateKeys,
-        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');
+    try {
+        return {
+            ...buildWorkerTaskContext({
+                taskId,
+                attempt,
+                taskToken,
+                taskType,
+                metadata,
+                prompt,
+                target: task.executionTarget,
+            }),
+            devPort,
+            env,
+        };
+    }
+    catch {
+        throw new Error(`task_context_invalid:${file}`);
     }
-    return prompt;
 }
 function hasAgentTaskUploadedArtifact(task) {
     return ((Number.isInteger(task.appId) && Number(task.appId) > 0)
@@ -829,41 +885,6 @@ function normalizeAssignmentWorkspaceRelativePath(value) {
     }
     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('/'));
@@ -873,12 +894,31 @@ function resolveWorkspaceFileDestination(workspaceDir, relativePath) {
     }
     return destination;
 }
-async function stageAssignmentWorkspaceFiles(workspaceDir, files) {
-    const normalizedFiles = normalizeAssignmentWorkspaceFiles(files);
-    for (const file of normalizedFiles) {
-        const destination = resolveWorkspaceFileDestination(workspaceDir, file.relativePath);
+async function stageAssignmentWorkspaceV2(workspaceDir, workspace) {
+    for (const file of workspace.files) {
+        const normalized = normalizeAssignmentContent({
+            path: file.path,
+            contentBase64: file.contentBase64,
+            sha256: file.sha256,
+            sizeBytes: file.sizeBytes,
+            code: 'agent_task_assignment_workspace_file',
+        });
+        const destination = resolveWorkspaceFileDestination(workspaceDir, normalized.path);
         await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
-        await (0, promises_1.writeFile)(destination, Buffer.from(file.contentBase64, 'base64'));
+        await (0, promises_1.writeFile)(destination, normalized.buffer);
+    }
+    for (const archive of workspace.archives) {
+        const normalized = normalizeAssignmentContent({
+            path: archive.path,
+            contentBase64: archive.contentBase64,
+            sha256: archive.sha256,
+            sizeBytes: archive.sizeBytes,
+            code: 'agent_task_assignment_workspace_archive',
+        });
+        const destination = resolveWorkspaceFileDestination(workspaceDir, normalized.path);
+        await (0, promises_1.mkdir)(destination, { recursive: true });
+        extractZipArchive(new Uint8Array(normalized.buffer), destination);
+        await removeStaleWorkerControlFiles(destination);
     }
 }
 function isFile(candidatePath) {
@@ -889,146 +929,6 @@ function isFile(candidatePath) {
         return false;
     }
 }
-function normalizePlaydropPluginManifestPath(input) {
-    if (typeof input.value !== 'string' || input.value.trim().length <= 0) {
-        throw new Error(`playdrop_plugin_staging_manifest_incomplete:${input.kind}: file paths must be non-empty strings in ${input.manifestPath}`);
-    }
-    if (input.value.includes('\0') || input.value.includes('\\')) {
-        throw new Error(`playdrop_plugin_staging_manifest_invalid_path:${input.kind}:${input.value}`);
-    }
-    if (node_path_1.default.isAbsolute(input.value) || /^[A-Za-z]:[\\/]/.test(input.value)) {
-        throw new Error(`playdrop_plugin_staging_manifest_invalid_path:${input.kind}:${input.value}`);
-    }
-    const normalized = node_path_1.default.posix.normalize(input.value);
-    if (normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
-        throw new Error(`playdrop_plugin_staging_manifest_invalid_path:${input.kind}:${input.value}`);
-    }
-    return normalized;
-}
-function readPlaydropPluginStagingManifest(pluginRoot) {
-    const resolvedRoot = node_path_1.default.resolve(pluginRoot);
-    const manifestPath = node_path_1.default.join(resolvedRoot, PLAYDROP_PLUGIN_STAGING_MANIFEST_PATH);
-    if (!isFile(manifestPath)) {
-        throw new Error(`playdrop_plugin_staging_manifest_missing: expected ${PLAYDROP_PLUGIN_STAGING_MANIFEST_PATH} under ${resolvedRoot}`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
-    }
-    catch (error) {
-        throw new Error(`playdrop_plugin_staging_manifest_invalid_json:${manifestPath}:${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`playdrop_plugin_staging_manifest_invalid:${manifestPath}`);
-    }
-    const rawManifest = parsed;
-    if (rawManifest.version !== 1) {
-        throw new Error(`playdrop_plugin_staging_manifest_unsupported_version:${manifestPath}`);
-    }
-    if (!rawManifest.taskFiles || typeof rawManifest.taskFiles !== 'object' || Array.isArray(rawManifest.taskFiles)) {
-        throw new Error(`playdrop_plugin_staging_manifest_incomplete: taskFiles missing in ${manifestPath}`);
-    }
-    const taskFiles = {};
-    const rawTaskFiles = rawManifest.taskFiles;
-    for (const kind of PLAYDROP_PLUGIN_MANIFEST_REQUIRED_STARTUP_KINDS) {
-        const rawFiles = rawTaskFiles[kind];
-        if (!Array.isArray(rawFiles) || rawFiles.length <= 0) {
-            throw new Error(`playdrop_plugin_staging_manifest_incomplete:${kind}: non-empty taskFiles entry required in ${manifestPath}`);
-        }
-        const seen = new Set();
-        const files = rawFiles.map((value) => normalizePlaydropPluginManifestPath({ manifestPath, kind, value }));
-        for (const relativePath of files) {
-            if (seen.has(relativePath)) {
-                throw new Error(`playdrop_plugin_staging_manifest_duplicate_file:${kind}:${relativePath}`);
-            }
-            seen.add(relativePath);
-            const source = node_path_1.default.resolve(resolvedRoot, ...relativePath.split('/'));
-            const relativeToRoot = node_path_1.default.relative(resolvedRoot, source);
-            if (relativeToRoot.startsWith('..') || node_path_1.default.isAbsolute(relativeToRoot)) {
-                throw new Error(`playdrop_plugin_staging_manifest_invalid_path:${kind}:${relativePath}`);
-            }
-            if (!isFile(source)) {
-                throw new Error(`playdrop_plugin_staging_manifest_file_missing:${kind}:${relativePath}`);
-            }
-        }
-        taskFiles[kind] = files;
-    }
-    for (const kind of WORKER_SUPPORTED_KINDS) {
-        if (taskFiles[kind]) {
-            continue;
-        }
-        const rawFiles = rawTaskFiles[kind];
-        if (rawFiles === undefined) {
-            continue;
-        }
-        if (!Array.isArray(rawFiles) || rawFiles.length <= 0) {
-            throw new Error(`playdrop_plugin_staging_manifest_incomplete:${kind}: non-empty taskFiles entry required in ${manifestPath}`);
-        }
-        const seen = new Set();
-        const files = rawFiles.map((value) => normalizePlaydropPluginManifestPath({ manifestPath, kind, value }));
-        for (const relativePath of files) {
-            if (seen.has(relativePath)) {
-                throw new Error(`playdrop_plugin_staging_manifest_duplicate_file:${kind}:${relativePath}`);
-            }
-            seen.add(relativePath);
-            const source = node_path_1.default.resolve(resolvedRoot, ...relativePath.split('/'));
-            const relativeToRoot = node_path_1.default.relative(resolvedRoot, source);
-            if (relativeToRoot.startsWith('..') || node_path_1.default.isAbsolute(relativeToRoot)) {
-                throw new Error(`playdrop_plugin_staging_manifest_invalid_path:${kind}:${relativePath}`);
-            }
-            if (!isFile(source)) {
-                throw new Error(`playdrop_plugin_staging_manifest_file_missing:${kind}:${relativePath}`);
-            }
-        }
-        taskFiles[kind] = files;
-    }
-    return {
-        version: 1,
-        taskFiles: taskFiles,
-    };
-}
-async function stagePlaydropPluginReferences(input) {
-    const pluginRoot = node_path_1.default.resolve(input.pluginRoot);
-    if (!WORKER_SUPPORTED_KINDS.includes(input.kind)) {
-        throw new Error(`unsupported_agent_task_kind:${input.kind}`);
-    }
-    const manifest = readPlaydropPluginStagingManifest(pluginRoot);
-    const referenceFiles = manifest.taskFiles[input.kind];
-    if (!Array.isArray(referenceFiles) || referenceFiles.length <= 0) {
-        throw new Error(`playdrop_plugin_staging_manifest_incomplete:${input.kind}: non-empty taskFiles entry required`);
-    }
-    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;
-}
-async function stageCodexTaskSkills(input) {
-    const skillRoot = node_path_1.default.join(input.workspaceDir, STAGED_CODEX_SKILL_ROOT);
-    await (0, promises_1.rm)(skillRoot, { recursive: true, force: true });
-    const stagedSkills = [];
-    for (const stagedPluginPath of input.stagedPluginPaths) {
-        const normalized = stagedPluginPath.replace(/\\/g, '/');
-        const match = /^\.playdrop\/plugin\/skills\/([^/]+)\/SKILL\.md$/.exec(normalized);
-        if (!match?.[1]) {
-            continue;
-        }
-        const source = resolveWorkspaceFileDestination(input.workspaceDir, normalized);
-        const destinationRelativePath = `${STAGED_CODEX_SKILL_ROOT}/${match[1]}/SKILL.md`;
-        const destination = resolveWorkspaceFileDestination(input.workspaceDir, destinationRelativePath);
-        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
-        await (0, promises_1.copyFile)(source, destination);
-        stagedSkills.push(destinationRelativePath);
-    }
-    if (stagedSkills.length <= 0) {
-        throw new Error('agent_task_codex_skills_missing');
-    }
-    return stagedSkills.sort();
-}
 function assertAssignmentPluginBundleExtractionBounds(buffer) {
     if (buffer.length < ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES) {
         throw new Error('agent_task_plugin_bundle_invalid_zip');
@@ -1094,15 +994,102 @@ function assertAssignmentPluginBundleExtractionBounds(buffer) {
         throw new Error('agent_task_plugin_bundle_invalid_zip');
     }
 }
+function normalizeAgentBundlePath(root, value, code) {
+    const relativePath = typeof value === 'string' ? value.trim().replace(/\\/g, '/') : '';
+    if (!relativePath
+        || relativePath.includes('\0')
+        || node_path_1.default.posix.isAbsolute(relativePath)
+        || relativePath === '..'
+        || relativePath.startsWith('../')) {
+        throw new Error(code);
+    }
+    const resolved = node_path_1.default.resolve(root, ...relativePath.split('/'));
+    if (!isPathInside(root, resolved)) {
+        throw new Error(code);
+    }
+    return resolved;
+}
+function readAgentBundleManifest(extractedRoot) {
+    const manifestPath = node_path_1.default.join(extractedRoot, AGENT_BUNDLE_MANIFEST_PATH);
+    if (!isFile(manifestPath)) {
+        throw new Error('agent_bundle_manifest_missing');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
+    }
+    catch {
+        throw new Error('agent_bundle_manifest_invalid_json');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('agent_bundle_manifest_invalid');
+    }
+    const manifest = parsed;
+    if (manifest.version !== 1
+        || !manifest.plugin
+        || typeof manifest.plugin.root !== 'string'
+        || !manifest.workspace
+        || !Array.isArray(manifest.workspace.files)) {
+        throw new Error('agent_bundle_manifest_invalid');
+    }
+    const pluginRoot = normalizeAgentBundlePath(extractedRoot, manifest.plugin.root, 'agent_bundle_plugin_root_invalid');
+    if (!isFile(node_path_1.default.join(pluginRoot, '.codex-plugin', 'plugin.json'))) {
+        throw new Error('agent_bundle_codex_plugin_manifest_missing');
+    }
+    if (!isFile(node_path_1.default.join(pluginRoot, '.claude-plugin', 'plugin.json'))) {
+        throw new Error('agent_bundle_claude_plugin_manifest_missing');
+    }
+    const destinations = new Set();
+    for (const entry of manifest.workspace.files) {
+        const source = normalizeAgentBundlePath(extractedRoot, entry?.source, 'agent_bundle_workspace_source_invalid');
+        if (!isFile(source)) {
+            throw new Error(`agent_bundle_workspace_source_missing:${entry?.source ?? ''}`);
+        }
+        const destination = typeof entry?.destination === 'string'
+            ? entry.destination.trim().replace(/\\/g, '/')
+            : '';
+        if (!destination
+            || node_path_1.default.posix.isAbsolute(destination)
+            || destination === '..'
+            || destination.startsWith('../')) {
+            throw new Error('agent_bundle_workspace_destination_invalid');
+        }
+        destinations.add(destination);
+    }
+    if (!destinations.has('AGENTS.md')) {
+        throw new Error('agent_bundle_agents_file_missing');
+    }
+    if (!destinations.has('CLAUDE.md')) {
+        throw new Error('agent_bundle_claude_file_missing');
+    }
+    return { manifest, pluginRoot };
+}
+async function stageAgentBundleWorkspaceFiles(extractedRoot, workspaceDir) {
+    const resolved = readAgentBundleManifest(extractedRoot);
+    for (const entry of resolved.manifest.workspace.files) {
+        const source = normalizeAgentBundlePath(extractedRoot, entry.source, 'agent_bundle_workspace_source_invalid');
+        const destination = resolveWorkspaceFileDestination(workspaceDir, entry.destination);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+        await (0, promises_1.copyFile)(source, destination);
+    }
+    return resolved.pluginRoot;
+}
 async function stageAssignmentPluginBundle(input) {
     const sha256 = typeof input.pluginBundle.sha256 === 'string' ? input.pluginBundle.sha256.trim() : '';
+    const fileName = typeof input.pluginBundle.fileName === 'string' ? input.pluginBundle.fileName.trim() : '';
     const contentBase64 = typeof input.pluginBundle.contentBase64 === 'string' ? input.pluginBundle.contentBase64.trim() : '';
-    if (!/^[a-f0-9]{64}$/.test(sha256) || !contentBase64) {
+    const sizeBytes = Number(input.pluginBundle.sizeBytes);
+    if (!/^[a-f0-9]{64}$/.test(sha256)
+        || !fileName
+        || node_path_1.default.basename(fileName) !== fileName
+        || !Number.isInteger(sizeBytes)
+        || sizeBytes <= 0
+        || !contentBase64) {
         throw new Error('agent_task_plugin_bundle_invalid');
     }
     const buffer = Buffer.from(contentBase64, 'base64');
-    if (buffer.length <= 0) {
-        throw new Error('agent_task_plugin_bundle_empty');
+    if (buffer.length !== sizeBytes) {
+        throw new Error('agent_task_plugin_bundle_size_mismatch');
     }
     const actualSha = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
     if (actualSha !== sha256) {
@@ -1140,8 +1127,7 @@ async function stageAssignmentPluginBundle(input) {
         await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
         await (0, promises_1.writeFile)(destination, Buffer.from(content));
     }
-    readPlaydropPluginStagingManifest(pluginRoot);
-    return pluginRoot;
+    return await stageAgentBundleWorkspaceFiles(pluginRoot, input.workspaceDir);
 }
 function resolveDevPluginWorkingTree(input) {
     const workingTree = input.workingTree?.trim();
@@ -1157,7 +1143,7 @@ function resolveDevPluginWorkingTree(input) {
         throw new Error(`worker_dev_plugin_working_tree_requires_dev_environment:${input.env}`);
     }
     const resolved = node_path_1.default.resolve(workingTree);
-    readPlaydropPluginStagingManifest(resolved);
+    readAgentBundleManifest(resolved);
     return resolved;
 }
 // A PlayDrop project root is the topmost directory holding a catalogue.json,
@@ -1570,6 +1556,7 @@ function buildWorkerCapabilities(input) {
 }
 function buildWorkerClaimBody(input) {
     return {
+        protocolVersion: 2,
         workerKey: input.workerKey,
         capabilities: {
             ...input.capabilities,
@@ -1577,89 +1564,43 @@ function buildWorkerClaimBody(input) {
         },
     };
 }
-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.
+// Extracts a server-provided workspace ZIP using fflate. Entries that resolve
+// outside the target directory fail the task immediately.
 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.');
+        throw new Error('agent_task_workspace_archive_empty');
+    }
+    if (names.length > ASSIGNMENT_PLUGIN_BUNDLE_MAX_FILES) {
+        throw new Error(`agent_task_workspace_archive_too_many_entries:${names.length}>${ASSIGNMENT_PLUGIN_BUNDLE_MAX_FILES}`);
     }
     const resolvedTarget = node_path_1.default.resolve(targetDir);
     const written = [];
+    let uncompressedBytes = 0;
     for (const originalName of names) {
         const name = originalName.replace(/\\/g, '/');
+        if (!name || name.startsWith('/') || name.split('/').includes('..')) {
+            throw new Error(`agent_task_workspace_archive_unsafe_entry:${originalName}`);
+        }
         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.`);
+            throw new Error(`agent_task_workspace_archive_unsafe_entry:${originalName}`);
         }
         if (name.endsWith('/')) {
             (0, node_fs_1.mkdirSync)(destination, { recursive: true });
             continue;
         }
+        uncompressedBytes += files[originalName].byteLength;
+        if (uncompressedBytes > ASSIGNMENT_WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES) {
+            throw new Error(`agent_task_workspace_archive_too_large:${uncompressedBytes}>${ASSIGNMENT_WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES}`);
+        }
         (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;
@@ -1842,30 +1783,9 @@ async function drainWorkerEventQueue(input) {
         (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.`);
-    }
-}
-async function removeStaleWorkerControlFilesFromBaseSource(stagingDir) {
+async function removeStaleWorkerControlFiles(stagingDir) {
     await (0, promises_1.rm)(node_path_1.default.join(stagingDir, '.playdrop.json'), { force: true });
 }
-// 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);
-    await removeStaleWorkerControlFilesFromBaseSource(stagingDir);
-    const stagedProjectDir = discoverWorkerProjectRoot(stagingDir);
-    const stagedBaseVersion = readWorkerProjectVersion(stagedProjectDir, input.baseApp.appName);
-    return { stagedProjectDir, stagedBaseVersion };
-}
 function resolveCodexModel(model, reasoningEffortOverride) {
     const normalized = model.trim();
     if (!normalized) {
@@ -2011,6 +1931,21 @@ async function runCodex(input) {
         workerUsername: input.workerUsername,
         envName: input.envName,
     });
+    if (input.taskPluginRoot) {
+        const pluginEnv = {
+            ...node_process_1.default.env,
+            HOME: homeDir,
+            CODEX_HOME: codexHomeDir,
+        };
+        await execFileAsync('codex', ['plugin', 'marketplace', 'add', input.taskPluginRoot, '--json'], {
+            cwd: input.workspaceDir,
+            env: pluginEnv,
+        });
+        await execFileAsync('codex', ['plugin', 'add', 'playdrop@playdrop', '--json'], {
+            cwd: input.workspaceDir,
+            env: pluginEnv,
+        });
+    }
     let observedCodexThreadId = null;
     let codexThreadProbe = '';
     const result = await (0, runtime_1.runLoggedProcess)({
@@ -2021,11 +1956,13 @@ async function runCodex(input) {
             reasoningEffort: input.codexModel.reasoningEffort,
             networkAccess: (0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_AGENT_NETWORK_ACCESS', false),
             sandboxMode: (0, runtime_1.readCodexSandboxMode)(),
+            imagePaths: input.imagePaths,
         }),
         cwd: input.workspaceDir,
         env: (0, runtime_1.buildWorkerChildEnv)({
             binDir: input.binDir,
             taskId: input.taskId,
+            taskToken: input.taskToken,
             attempt: input.attempt,
             envName: input.envName,
             eventDir: input.eventDir,
@@ -2106,6 +2043,7 @@ async function runClaude(input) {
         env: (0, runtime_1.buildWorkerChildEnv)({
             binDir: input.binDir,
             taskId: input.taskId,
+            taskToken: input.taskToken,
             attempt: input.attempt,
             envName: input.envName,
             eventDir: input.eventDir,
@@ -2113,7 +2051,23 @@ async function runClaude(input) {
             playdropConfigPath,
             playwrightBrowsersPath: resolveWorkerPlaywrightBrowsersPath(),
         }),
-        stdin: input.prompt,
+        stdin: `${JSON.stringify({
+            type: 'user',
+            message: {
+                role: 'user',
+                content: [
+                    { type: 'text', text: input.prompt },
+                    ...input.imageAttachments.map((attachment) => ({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: attachment.contentType,
+                            data: (0, node_fs_1.readFileSync)(attachment.path).toString('base64'),
+                        },
+                    })),
+                ],
+            },
+        })}\n`,
         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,
@@ -2163,6 +2117,13 @@ function buildAgentRunResult(result) {
         tokensUsed: result.tokensUsed,
     };
 }
+function agentFailureRawError(result) {
+    return [result.stderr, result.stdout, result.outputTail]
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .join('\n')
+        || 'agent_failure';
+}
 function buildSupervisorFailureRunResult(message) {
     return {
         exitCode: null,
@@ -2183,22 +2144,33 @@ function buildSupervisorFailureRunResult(message) {
         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);
+function listPluginSkillPaths(pluginRoot) {
+    if (!pluginRoot) {
+        return [];
     }
-    return normalized;
-}
-function normalizeTelemetrySkillPaths(stagedPaths) {
-    return Array.from(new Set(stagedPaths.map(stripStagedPlaydropPluginPrefix).filter(Boolean))).sort();
+    const skillsRoot = node_path_1.default.join(pluginRoot, 'skills');
+    if (!(0, node_fs_1.existsSync)(skillsRoot)) {
+        return [];
+    }
+    const paths = [];
+    const visit = (directory) => {
+        for (const entry of (0, node_fs_1.readdirSync)(directory, { withFileTypes: true })) {
+            const entryPath = node_path_1.default.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                visit(entryPath);
+            }
+            else if (entry.isFile() && entry.name === 'SKILL.md') {
+                paths.push(node_path_1.default.relative(pluginRoot, entryPath).replace(/\\/g, '/'));
+            }
+        }
+    };
+    visit(skillsRoot);
+    return paths.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}`)) {
+        if (output.includes(availablePath)) {
             observed.add(availablePath);
         }
     }
@@ -2219,8 +2191,8 @@ async function recordAgentRunTelemetry(input) {
         workerKey: input.workerKey,
         leaseToken: input.leaseToken,
         attempt: input.task.attempts,
-        agent: input.assignment.agent,
-        requestedModel: input.assignment.model,
+        agent: input.assignment.agent.runtime,
+        requestedModel: input.assignment.agent.model,
         resolvedRuntimeModel: input.resolvedRuntimeModel,
         reasoningEffort: input.reasoningEffort,
         status: resolveTelemetryStatus(input.status),
@@ -2240,6 +2212,11 @@ async function recordAgentRunTelemetry(input) {
         observedSkillPaths: [...observedSkillPaths].sort(),
         startedAt: input.startedAt.toISOString(),
         completedAt: input.completedAt.toISOString(),
+        ...(input.status === 'FAILED'
+            ? {
+                terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(agentFailureRawError(input.result), 'agent'),
+            }
+            : {}),
     });
 }
 function providerNameForAgent(agent) {
@@ -2713,14 +2690,6 @@ function buildWorkerSetupActions(input) {
             message: 'The PlayDrop CLI package could not load playwright-core from its installed dependencies.',
         });
     }
-    if (reasons.has('playdrop_plugin_staging_manifest_missing')) {
-        actions.push({
-            reason: 'playdrop_plugin_staging_manifest_missing',
-            label: 'Install or update the PlayDrop agent plugin',
-            command: 'playdrop agents status --json',
-            message: 'Run the CLI-reported nextAction.command for a supported local agent so playdrop-worker-staging.json is available.',
-        });
-    }
     if (reasons.has('agent_cli_not_found')) {
         actions.push({
             reason: 'agent_cli_not_found',
@@ -3591,8 +3560,14 @@ async function setupWorker(options = {}) {
     }, { env: options.env });
 }
 async function failTaskWithRetry(client, taskId, body) {
+    const terminalReason = body.terminalReason ?? (0, types_1.classifyAgentTaskTerminalReason)(body.error, 'worker');
+    const requestBody = {
+        ...body,
+        error: terminalReason.code,
+        terminalReason,
+    };
     try {
-        await client.workerFailAgentTask(taskId, body);
+        await client.workerFailAgentTask(taskId, requestBody);
     }
     catch (firstError) {
         if (isAgentTaskNotRunningError(firstError)) {
@@ -3600,7 +3575,7 @@ async function failTaskWithRetry(client, taskId, body) {
         }
         await sleep(FAIL_REPORT_RETRY_DELAY_MS);
         try {
-            await client.workerFailAgentTask(taskId, body);
+            await client.workerFailAgentTask(taskId, requestBody);
         }
         catch (secondError) {
             if (isAgentTaskNotRunningError(secondError)) {
@@ -3620,13 +3595,24 @@ async function fetchTaskDetail(client, target, taskId) {
     return await client.getAgentTask(taskId);
 }
 function instrumentTaskChromeTitleMatchers(assignment) {
-    const targets = assignment.kind === 'GAME_REVIEW'
-        ? [assignment.inputs.reviewTarget]
-        : assignment.kind === 'GAME_EVAL'
-            ? assignment.inputs.evalTarget?.targets ?? []
+    const playdrop = assignment.task.metadata.playdrop;
+    const metadata = playdrop && typeof playdrop === 'object' && !Array.isArray(playdrop)
+        ? playdrop
+        : {};
+    const kind = metadata.kind;
+    const evalTarget = metadata.evalTarget && typeof metadata.evalTarget === 'object' && !Array.isArray(metadata.evalTarget)
+        ? metadata.evalTarget
+        : null;
+    const targets = kind === 'GAME_REVIEW'
+        ? [metadata.reviewTarget]
+        : kind === 'GAME_EVAL' && Array.isArray(evalTarget?.targets)
+            ? evalTarget.targets
             : [];
     const matchers = new Set();
-    for (const target of targets) {
+    for (const rawTarget of targets) {
+        const target = rawTarget && typeof rawTarget === 'object' && !Array.isArray(rawTarget)
+            ? rawTarget
+            : null;
         if (!target)
             continue;
         for (const value of [target.appDisplayName, target.appName]) {
@@ -3719,7 +3705,7 @@ on run matchers
 end run
 `;
 async function enforceInstrumentBrowserHygiene(assignment, options = {}) {
-    if (assignment.kind !== 'GAME_REVIEW' && assignment.kind !== 'GAME_EVAL') {
+    if (assignment.agent.browser === 'NONE') {
         return { remainingTaskTabs: 0, blankWindows: 0 };
     }
     if ((options.platform ?? node_process_1.default.platform) !== 'darwin') {
@@ -3927,11 +3913,19 @@ async function startWorker(options = {}) {
                 });
             }, HEARTBEAT_INTERVAL_MS);
             const runClaimedTask = async (claim, devPort) => {
-                const task = claim.task;
-                if (!task) {
-                    throw new Error('agent_task_claim_missing_task');
+                const claimedAssignment = normalizeWorkerTaskAssignmentV2(claim);
+                if (!claimedAssignment) {
+                    throw new Error('agent_task_claim_missing_assignment');
                 }
-                const leaseToken = claim.leaseToken?.trim();
+                const taskContext = buildWorkerTaskContextV2(claimedAssignment);
+                const task = {
+                    id: claimedAssignment.task.id,
+                    kind: taskContext.kind,
+                    model: claimedAssignment.agent.model,
+                    executionTarget: claimedAssignment.task.executionTarget,
+                    attempts: claimedAssignment.task.attempt,
+                };
+                const leaseToken = claim.action === 'run' ? claim.lease.token.trim() : '';
                 if (!leaseToken) {
                     throw new Error('agent_task_claim_missing_lease_token');
                 }
@@ -3946,7 +3940,7 @@ async function startWorker(options = {}) {
                 let workspaceDir = null;
                 let availableSkillPaths = [];
                 const observedSkillPaths = new Set();
-                let assignment = null;
+                const assignment = claimedAssignment;
                 let resolvedRuntimeModel = task.model;
                 let reasoningEffort = null;
                 let agentStartedAt = null;
@@ -3955,9 +3949,6 @@ async function startWorker(options = {}) {
                 let telemetryReported = false;
                 let heartbeatTransientFailures = 0;
                 const reportTelemetry = async (status, setupError) => {
-                    if (!assignment) {
-                        return;
-                    }
                     const completedAt = agentCompletedAt ?? new Date();
                     await recordAgentRunTelemetry({
                         client,
@@ -3977,24 +3968,19 @@ async function startWorker(options = {}) {
                     telemetryReported = true;
                 };
                 try {
-                    assignment = resolveWorkerClaimTaskAssignment(claim);
-                    if (!assignment) {
-                        throw new Error('agent_task_claim_missing_task_assignment');
-                    }
-                    const codexModel = assignment.agent === 'CODEX'
-                        ? resolveCodexModel(assignment.model, assignment.reasoningEffort)
+                    const codexModel = assignment.agent.runtime === 'CODEX'
+                        ? resolveCodexModel(assignment.agent.model, assignment.agent.reasoningEffort)
                         : null;
-                    const claudeModel = assignment.agent === 'CLAUDE_CODE'
-                        ? resolveClaudeModel(assignment.model, assignment.reasoningEffort)
+                    const claudeModel = assignment.agent.runtime === 'CLAUDE_CODE'
+                        ? resolveClaudeModel(assignment.agent.model, assignment.agent.reasoningEffort)
                         : null;
-                    resolvedRuntimeModel = codexModel?.model ?? claudeModel?.model ?? assignment.model;
+                    resolvedRuntimeModel = codexModel?.model ?? claudeModel?.model ?? assignment.agent.model;
                     reasoningEffort = codexModel?.reasoningEffort ?? claudeModel?.effort ?? null;
-                    const taskContext = buildWorkerTaskContext(claim, assignment);
                     workspaceDir = workerTaskWorkspaceDirFromAssignment(assignment);
                     await pruneWorkerTaskWorkspaces(workspaceDir);
                     await (0, promises_1.rm)(workspaceDir, { recursive: true, force: true });
                     await (0, promises_1.mkdir)(workspaceDir, { recursive: true });
-                    const eventDir = node_path_1.default.join(workspaceDir, '.playdrop-task-events');
+                    const eventDir = node_path_1.default.join(workspaceDir, '.playdrop', 'task-events');
                     await (0, promises_1.mkdir)(eventDir, { recursive: true });
                     await stageWorkerTaskContext({
                         workspaceDir,
@@ -4039,52 +4025,16 @@ async function startWorker(options = {}) {
                         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,
-                    });
-                    const assignmentPluginRoot = devPluginWorkingTree ?? await stageAssignmentPluginBundle({
-                        workspaceDir,
-                        pluginBundle: assignment.pluginBundle,
-                    });
-                    const stagedPluginPaths = await stagePlaydropPluginReferences({
-                        workspaceDir,
-                        pluginRoot: assignmentPluginRoot,
-                        kind: task.kind,
-                    });
-                    if (assignment.agent === 'CODEX') {
-                        await stageCodexTaskSkills({ workspaceDir, stagedPluginPaths });
-                    }
-                    availableSkillPaths = normalizeTelemetrySkillPaths(stagedPluginPaths);
-                    await client.workerCreateAgentTaskEvent(task.id, {
-                        workerKey,
-                        leaseToken,
-                        kind: 'progress',
-                        phase: 'setup',
-                        message: devPluginWorkingTree
-                            ? 'Staged PlayDrop plugin references from explicit dev working tree'
-                            : 'Staged PlayDrop plugin references from server task bundle',
-                        pct: 3,
-                        payload: {
-                            pluginSource: devPluginWorkingTree ? 'DEV_WORKING_TREE' : 'SERVER_TASK_BUNDLE',
-                            bundleSha: assignment.pluginBundle.sha256,
-                        },
-                    });
-                    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);
-                    }
+                    await stageAssignmentWorkspaceV2(workspaceDir, assignment.workspace);
+                    const assignmentPluginRoot = devPluginWorkingTree
+                        ? await stageAgentBundleWorkspaceFiles(devPluginWorkingTree, workspaceDir)
+                        : assignment.plugin
+                            ? await stageAssignmentPluginBundle({
+                                workspaceDir,
+                                pluginBundle: assignment.plugin,
+                            })
+                            : null;
+                    availableSkillPaths = listPluginSkillPaths(assignmentPluginRoot);
                     heartbeatTimer = setInterval(() => {
                         client.workerHeartbeatAgentTask(task.id, { workerKey, leaseToken })
                             .then((heartbeat) => {
@@ -4143,57 +4093,18 @@ async function startWorker(options = {}) {
                             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' || task.kind === 'REMIX_GAME') {
-                        if (assignment.inputs.baseSource !== null) {
-                            throw new Error('agent_task_assignment_unexpected_base_source');
-                        }
-                        if (task.kind === 'REMIX_GAME' && !assignment.inputs.remixSource) {
-                            throw new Error('agent_task_assignment_remix_source_missing');
-                        }
-                    }
-                    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 if (task.kind === 'GAME_EVAL') {
-                        if (assignment.inputs.baseSource !== null) {
-                            throw new Error('agent_task_assignment_unexpected_base_source');
-                        }
-                        if (!assignment.inputs.evalTarget) {
-                            throw new Error('agent_task_assignment_eval_target_missing');
-                        }
-                    }
-                    else {
-                        throw new Error(`unsupported_agent_task_kind:${task.kind}`);
-                    }
+                    const prompt = assignment.request.prompt;
+                    const imageAttachments = assignment.request.attachments
+                        .filter((attachment) => attachment.contentType.startsWith('image/'))
+                        .map((attachment) => ({
+                        path: resolveWorkspaceFileDestination(workspaceDir, attachment.path),
+                        contentType: attachment.contentType,
+                    }));
                     if (shuttingDown) {
                         throw new Error('worker_shutdown');
                     }
                     agentStartedAt = new Date();
-                    if (assignment.agent === 'CODEX') {
+                    if (assignment.agent.runtime === 'CODEX') {
                         agentResult = await runCodex({
                             workspaceDir,
                             binDir,
@@ -4202,9 +4113,12 @@ async function startWorker(options = {}) {
                             envName: env,
                             workerUsername: username,
                             taskId: task.id,
+                            taskToken: assignment.task.token,
                             attempt: taskContext.attempt,
                             devPort,
-                            codexModel: codexModel ?? resolveCodexModel(assignment.model),
+                            codexModel: codexModel ?? resolveCodexModel(assignment.agent.model),
+                            taskPluginRoot: assignmentPluginRoot,
+                            imagePaths: imageAttachments.map((attachment) => attachment.path),
                             onTranscriptChunks: async (chunks) => {
                                 await appendTranscriptChunks(chunks);
                             },
@@ -4213,21 +4127,23 @@ async function startWorker(options = {}) {
                             },
                         });
                     }
-                    else if (assignment.agent === 'CLAUDE_CODE') {
+                    else if (assignment.agent.runtime === 'CLAUDE_CODE') {
                         agentResult = await runClaude({
                             workspaceDir,
                             binDir,
                             eventDir,
                             prompt,
-                            enableChrome: false,
-                            enablePlaywrightMcp: task.kind === 'GAME_REVIEW' || task.kind === 'GAME_EVAL',
+                            enableChrome: assignment.agent.browser === 'CHROME',
+                            enablePlaywrightMcp: assignment.agent.browser === 'PLAYWRIGHT',
                             envName: env,
                             workerUsername: username,
                             taskId: task.id,
+                            taskToken: assignment.task.token,
                             attempt: taskContext.attempt,
                             devPort,
-                            claudeModel: claudeModel ?? resolveClaudeModel(assignment.model),
+                            claudeModel: claudeModel ?? resolveClaudeModel(assignment.agent.model),
                             taskPluginRoot: assignmentPluginRoot,
+                            imageAttachments,
                             onTranscriptChunks: async (chunks) => {
                                 await appendTranscriptChunks(chunks);
                             },
@@ -4236,17 +4152,11 @@ async function startWorker(options = {}) {
                             },
                         });
                     }
-                    else if (assignment.agent === 'CURSOR_COMPOSER') {
-                        const assignmentAgent = assignment.agent;
-                        const assignmentModel = assignment.model;
-                        const plannedAttemptIndex = assignment.attemptPlan?.options.findIndex((option) => option.agent === assignmentAgent && option.model === assignmentModel);
-                        const attemptIndex = typeof plannedAttemptIndex === 'number' && plannedAttemptIndex >= 0
-                            ? plannedAttemptIndex
-                            : 0;
+                    else if (assignment.agent.runtime === 'CURSOR_COMPOSER') {
                         await client.workerRecordAgentTaskAttemptUnavailable(task.id, {
                             workerKey,
                             leaseToken,
-                            attemptIndex,
+                            attemptIndex: 0,
                             reason: 'unavailable_runtime',
                             message: 'Cursor Composer noninteractive worker execution is not configured on this worker.',
                         });
@@ -4254,7 +4164,7 @@ async function startWorker(options = {}) {
                         throw new Error('worker_cursor_composer_runner_not_configured');
                     }
                     else {
-                        throw new Error(`unsupported_worker_agent:${assignment.agent}`);
+                        throw new Error(`unsupported_worker_agent:${assignment.agent.runtime}`);
                     }
                     agentCompletedAt = new Date();
                     await queueEventDrain().catch((error) => {
@@ -4313,8 +4223,8 @@ async function startWorker(options = {}) {
                         }
                         else {
                             retainWorkspace = true;
-                            const failureCode = buildAgentFailureCode(assignment.agent, completedAgentResult, {
-                                model: assignment.model,
+                            const failureCode = buildAgentFailureCode(assignment.agent.runtime, completedAgentResult, {
+                                model: assignment.agent.model,
                                 reasoningEffort,
                             });
                             await client.workerCreateAgentTaskEvent(task.id, {
@@ -4330,6 +4240,7 @@ async function startWorker(options = {}) {
                                 workerKey,
                                 leaseToken,
                                 error: failureCode,
+                                terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(agentFailureRawError(completedAgentResult), 'agent'),
                                 result: agentRunResult,
                             });
                             await reportTelemetry('FAILED');
@@ -4416,6 +4327,7 @@ async function startWorker(options = {}) {
                                 workerKey,
                                 leaseToken,
                                 error: normalizeWorkerFailureErrorCode(message),
+                                terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(message, 'worker'),
                                 result: { workerError: message },
                             });
                         }
@@ -4438,9 +4350,8 @@ async function startWorker(options = {}) {
                     if (eventDrainTimer) {
                         clearInterval(eventDrainTimer);
                     }
-                    if (assignment
-                        && agentStartedAt
-                        && (assignment.kind === 'GAME_REVIEW' || assignment.kind === 'GAME_EVAL')) {
+                    if (agentStartedAt
+                        && assignment.agent.browser !== 'NONE') {
                         try {
                             const hygiene = await enforceInstrumentBrowserHygiene(assignment);
                             console.log(`Agent task ${task.id} browser hygiene passed: ${hygiene.remainingTaskTabs} task tabs, ${hygiene.blankWindows} blank window(s).`);
@@ -4514,8 +4425,7 @@ async function startWorker(options = {}) {
                         claimBackoffMs = nextClaimBackoffMs(claimBackoffMs);
                         continue;
                     }
-                    const task = claim.task;
-                    if (!task) {
+                    if (claim.action !== 'run') {
                         if (shuttingDown || quiescingForUpdate) {
                             break;
                         }
@@ -4525,18 +4435,19 @@ async function startWorker(options = {}) {
                         await sleep(DEFAULT_POLL_INTERVAL_MS);
                         continue;
                     }
-                    activeTaskIds.add(task.id);
+                    const taskId = claim.assignment.task.id;
+                    activeTaskIds.add(taskId);
                     activeDevPorts.add(devPort);
                     const taskRun = runClaimedTask(claim, devPort)
                         .catch((error) => {
                         recordFatalTaskError(error);
                     })
                         .finally(() => {
-                        activeTaskRuns.delete(task.id);
-                        activeTaskIds.delete(task.id);
+                        activeTaskRuns.delete(taskId);
+                        activeTaskIds.delete(taskId);
                         activeDevPorts.delete(devPort);
                     });
-                    activeTaskRuns.set(task.id, taskRun);
+                    activeTaskRuns.set(taskId, taskRun);
                     if (options.once) {
                         await taskRun;
                         if (fatalTaskError) {
@@ -4633,6 +4544,21 @@ async function reportTask(options) {
     }
     resolveWorkerTaskStateForWrite();
 }
+function showTaskContext() {
+    const taskContext = readTaskContextFile();
+    console.log(JSON.stringify({
+        task: {
+            id: taskContext.taskId,
+            type: taskContext.taskType,
+            attempt: taskContext.attempt,
+            executionTarget: taskContext.target,
+            metadata: taskContext.metadata,
+        },
+        request: {
+            prompt: taskContext.creatorRequest,
+        },
+    }, null, 2));
+}
 async function reportCatalogueTask(options) {
     const message = options.message?.trim();
     if (!message) {
@@ -4668,11 +4594,26 @@ async function resolveTaskCommandContext(command, optionsEnv, taskContext) {
     if (!ctx) {
         return null;
     }
-    const me = await ctx.client.me();
+    const taskClientOptions = {
+        token: ctx.token,
+        onBehalfCreatorUsername: taskContext.creatorUsername,
+        agentTaskToken: taskContext.taskToken,
+        agentTaskId: taskContext.taskId,
+        agentTaskAttempt: taskContext.attempt,
+    };
+    const client = (0, apiClient_1.createCliApiClient)({
+        ...taskClientOptions,
+        baseUrl: ctx.envConfig.apiBase,
+    });
+    const aiClient = (0, apiClient_1.createCliAiClient)({
+        ...taskClientOptions,
+        baseUrl: ctx.envConfig.aiBase,
+    });
+    const me = await client.me();
     if (!me.user) {
         throw new Error('task_context_user_missing');
     }
-    return { ...ctx, user: me.user };
+    return { ...ctx, client, aiClient, user: me.user };
 }
 async function uploadTask(options = {}) {
     const taskContext = readTaskContextFile();
@@ -4811,6 +4752,7 @@ async function completeTask(options) {
             await ctx.client.workerFailAgentTask(taskContext.taskId, {
                 taskToken: taskContext.taskToken,
                 error: 'remix_relation_missing',
+                terminalReason: (0, types_1.classifyAgentTaskTerminalReason)('upload_validation:remix_relation_missing', 'agent'),
                 result: {
                     appId: uploadResult.appId,
                     appVersionId: uploadResult.appVersionId,
@@ -5074,6 +5016,7 @@ async function instrumentErrorTask(options) {
     await ctx.client.workerFailAgentTask(taskContext.taskId, {
         taskToken: taskContext.taskToken,
         error: `instrument_error:${reason}`,
+        terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(`instrument_error:${reason}`, 'instrument'),
         result: {
             outcome: 'instrument_error',
             reason,
@@ -5097,6 +5040,7 @@ async function failTask(options) {
     await ctx.client.workerFailAgentTask(taskContext.taskId, {
         taskToken: taskContext.taskToken,
         error: message,
+        terminalReason: (0, types_1.classifyAgentTaskTerminalReason)(message, 'agent'),
         result: { failedBy: 'agent' },
     });
     (0, output_1.printSuccess)('Task marked failed. This was the final operation; send one short final status sentence and stop immediately.');