@playdrop/playdrop-cli 0.10.0 → 0.10.1

package/dist/commands/worker.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = exports.WORKER_SESSION_EXPIRED_MESSAGE = exports.runLoggedProcess = exports.readCodexSandboxMode = exports.readEnvBoolean = exports.extractCodexTokensUsed = exports.buildWorkerChildEnv = exports.buildClaudePermissionSettings = exports.buildClaudeExecArgs = exports.buildCodexExecArgs = exports.assertWorkerTokenUsageWithinCap = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
+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;
@@ -39,6 +39,8 @@ 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");
@@ -55,6 +57,7 @@ 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; } });
@@ -64,6 +67,7 @@ Object.defineProperty(exports, "buildCodexExecArgs", { enumerable: true, get: fu
 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; } });
@@ -78,13 +82,14 @@ 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'];
+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';
@@ -92,7 +97,7 @@ 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_REFERENCE_FILES = [
+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,
@@ -105,13 +110,48 @@ const PLAYDROP_PLUGIN_REFERENCE_FILES = [
     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'],
@@ -174,7 +214,7 @@ function normalizeAssignmentAgent(value) {
     return value;
 }
 function normalizeAssignmentKind(value, task) {
-    if (value !== 'NEW_GAME' && value !== 'GAME_UPDATE') {
+    if (value !== 'NEW_GAME' && value !== 'GAME_UPDATE' && value !== 'GAME_REVIEW') {
         throw new Error('agent_task_assignment_kind_missing');
     }
     if (value !== task.kind) {
@@ -251,6 +291,7 @@ function resolveWorkerClaimTaskAssignment(claim) {
             },
             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,
@@ -303,15 +344,31 @@ function buildWorkerTaskContext(claim, assignment) {
     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,
@@ -319,6 +376,7 @@ function buildWorkerTaskContext(claim, assignment) {
         target: assignment.target,
         outputAppName,
         outputVersion,
+        reviewAppVersionId,
     };
 }
 function workerTaskContextPath(workspaceDir) {
@@ -339,6 +397,8 @@ async function stageWorkerTaskContext(input) {
     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');
@@ -361,25 +421,36 @@ 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 !== '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,
@@ -387,6 +458,7 @@ function readTaskContextFile(startDir = node_process_1.default.cwd()) {
         target: parsed.target,
         outputAppName: typeof parsed.outputAppName === 'string' && parsed.outputAppName.trim() ? parsed.outputAppName.trim() : null,
         outputVersion,
+        reviewAppVersionId,
         devPort,
         env,
     };
@@ -588,8 +660,18 @@ async function stagePlaydropPluginReferences(input) {
     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 PLAYDROP_PLUGIN_REFERENCE_FILES) {
+    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 });
@@ -1291,6 +1373,7 @@ async function runCodex(input) {
         env: (0, runtime_1.buildWorkerChildEnv)({
             binDir: input.binDir,
             taskId: input.taskId,
+            attempt: input.attempt,
             envName: input.envName,
             eventDir: input.eventDir,
             devPort: input.devPort,
@@ -1317,6 +1400,7 @@ async function runClaude(input) {
         env: (0, runtime_1.buildWorkerChildEnv)({
             binDir: input.binDir,
             taskId: input.taskId,
+            attempt: input.attempt,
             envName: input.envName,
             eventDir: input.eventDir,
             devPort: input.devPort,
@@ -1366,6 +1450,93 @@ function buildAgentRunResult(result) {
         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';
 }
@@ -1634,11 +1805,49 @@ async function startWorker(options = {}) {
             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 {
-                const assignment = resolveWorkerClaimTaskAssignment(claim);
+                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 });
@@ -1669,6 +1878,20 @@ async function startWorker(options = {}) {
                     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,
@@ -1677,7 +1900,7 @@ async function startWorker(options = {}) {
                     message: 'Preparing worker workspace',
                     pct: 2,
                 });
-                await stagePlaydropPluginReferences({ workspaceDir, pluginRoot: playdropPluginRoot });
+                availableSkillPaths = normalizeTelemetrySkillPaths(await stagePlaydropPluginReferences({ workspaceDir, pluginRoot: playdropPluginRoot, kind: task.kind }));
                 await client.workerCreateAgentTaskEvent(task.id, {
                     workerKey,
                     leaseToken,
@@ -1747,13 +1970,22 @@ async function startWorker(options = {}) {
                         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');
                 }
-                const agentResult = assignment.agent === 'CODEX'
+                agentStartedAt = new Date();
+                agentResult = assignment.agent === 'CODEX'
                     ? await runCodex({
                         workspaceDir,
                         binDir,
@@ -1761,10 +1993,11 @@ async function startWorker(options = {}) {
                         prompt,
                         envName: env,
                         taskId: task.id,
+                        attempt: taskContext.attempt,
                         devPort,
-                        codexModel: resolveCodexModel(assignment.model),
+                        codexModel: codexModel ?? resolveCodexModel(assignment.model),
                         onTranscriptChunks: async (chunks) => {
-                            await appendWorkerTranscriptChunks({ client, taskId: task.id, workerKey, leaseToken, chunks });
+                            await appendTranscriptChunks(chunks);
                         },
                         onChild: (controls) => {
                             activeTerminators.set(task.id, controls.terminate);
@@ -1777,22 +2010,33 @@ async function startWorker(options = {}) {
                         prompt,
                         envName: env,
                         taskId: task.id,
+                        attempt: taskContext.attempt,
                         devPort,
-                        claudeModel: resolveClaudeModel(assignment.model),
+                        claudeModel: claudeModel ?? resolveClaudeModel(assignment.model),
                         playdropPluginRoot,
                         onTranscriptChunks: async (chunks) => {
-                            await appendWorkerTranscriptChunks({ client, taskId: task.id, workerKey, leaseToken, chunks });
+                            await appendTranscriptChunks(chunks);
                         },
                         onChild: (controls) => {
                             activeTerminators.set(task.id, controls.terminate);
                         },
                     });
+                agentCompletedAt = new Date();
                 await queueEventDrain().catch((error) => {
                     handleEventDrainFailure(error);
                 });
-                const agentRunResult = buildAgentRunResult(agentResult);
+                const completedAgentResult = agentResult;
+                const agentRunResult = buildAgentRunResult(completedAgentResult);
                 if (fenced) {
-                    console.error(`Agent task ${task.id} was aborted by the server; cleaning up without reporting failure.`);
+                    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
@@ -1811,12 +2055,14 @@ async function startWorker(options = {}) {
                         error: 'worker_shutdown',
                         result: agentRunResult,
                     });
+                    await reportTelemetry('FAILED');
                 }
-                else if (agentResult.timedOut || agentResult.exitCode !== 0 || agentResult.signal) {
+                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;
@@ -1828,10 +2074,11 @@ async function startWorker(options = {}) {
                             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, agentResult);
+                        const failureCode = buildAgentFailureCode(assignment.agent, completedAgentResult);
                         await client.workerCreateAgentTaskEvent(task.id, {
                             workerKey,
                             leaseToken,
@@ -1847,6 +2094,7 @@ async function startWorker(options = {}) {
                             error: failureCode,
                             result: agentRunResult,
                         });
+                        await reportTelemetry('FAILED');
                     }
                 }
                 else {
@@ -1854,6 +2102,7 @@ async function startWorker(options = {}) {
                     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;
@@ -1865,6 +2114,7 @@ async function startWorker(options = {}) {
                             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);
@@ -1880,8 +2130,9 @@ async function startWorker(options = {}) {
                                 workerKey,
                                 leaseToken,
                                 kind: 'progress',
-                                message: `Token usage ${agentResult.tokensUsed} exceeded the worker token cap of ${tokenCap}.`,
+                                message: `Token usage ${completedAgentResult.tokensUsed} exceeded the worker token cap of ${tokenCap}.`,
                             });
+                            await reportTelemetry('FAILED');
                             throw error;
                         }
                         if (!tokenUsageKnown) {
@@ -1906,6 +2157,7 @@ async function startWorker(options = {}) {
                             error: 'agent_exited_without_task_done',
                             result: agentRunResult,
                         });
+                        await reportTelemetry('FAILED');
                     }
                 }
             }
@@ -1921,12 +2173,24 @@ async function startWorker(options = {}) {
                     console.error(`Agent task ${task.id} failed in the worker: ${message}`);
                 }
                 if (!fenced && !isAgentTaskNotRunningError(error)) {
-                    await failTaskWithRetry(client, task.id, {
-                        workerKey,
-                        leaseToken,
-                        error: normalizeWorkerFailureErrorCode(message),
-                        result: { workerError: message },
-                    });
+                    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 {
@@ -2123,6 +2387,9 @@ async function resolveTaskCommandContext(command, optionsEnv, taskContext) {
 }
 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);
@@ -2169,6 +2436,9 @@ async function uploadTask(options = {}) {
 }
 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;
@@ -2198,6 +2468,143 @@ async function completeTask(options) {
     });
     (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) {