@playdrop/playdrop-cli 0.10.0 → 0.10.2

package/dist/commands/review.js

@@ -0,0 +1,353 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_REVIEW_EVIDENCE_FILES = exports.REVIEW_CRITERIA = void 0;
+exports.validateGameReviewResult = validateGameReviewResult;
+exports.validateReviewResultCommand = validateReviewResultCommand;
+exports.composeReviewEvidence = composeReviewEvidence;
+exports.createReviewRatingCard = createReviewRatingCard;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const sharp_1 = __importDefault(require("sharp"));
+const output_1 = require("../output");
+exports.REVIEW_CRITERIA = [
+    'Gameplay / Core Loop',
+    'Depth / Replayability',
+    'Controls / Input',
+    'UX / Usability',
+    'First Time User Experience',
+    'Visuals / Art Direction',
+    'Audio / Feedback',
+    'Store Listing & Metadata Accuracy',
+    'Safety / Age Rating / Compliance',
+    'Performance / Stability',
+];
+const TERMINAL_REVIEW_STATES = new Set([
+    'FAILED',
+    'LOW_QUALITY',
+    'PASSED',
+    'GOOD',
+    'EXCELLENT',
+]);
+const STATE_OUTCOME = {
+    EXCELLENT: 'Excellent',
+    FAILED: 'Blocked',
+    GOOD: 'Good',
+    LOW_QUALITY: 'Limited',
+    PASSED: 'Passed',
+};
+exports.REQUIRED_REVIEW_EVIDENCE_FILES = [
+    'core.png',
+    'win.png',
+    'loss.png',
+    'composite.png',
+    'rating-card.png',
+];
+const REVIEW_EVIDENCE_MAX_BYTES = 10 * 1024 * 1024;
+function resolveFilePath(filePath, code) {
+    const normalized = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalized) {
+        throw new Error(code);
+    }
+    return node_path_1.default.isAbsolute(normalized) ? normalized : node_path_1.default.resolve(process.cwd(), normalized);
+}
+async function readRequiredTextFile(filePath, code) {
+    const resolved = resolveFilePath(filePath, code);
+    const content = await node_fs_1.promises.readFile(resolved, 'utf8');
+    if (!content.trim()) {
+        throw new Error(code);
+    }
+    return content;
+}
+function requireLine(text, prefix) {
+    const line = text.split(/\r?\n/).find((entry) => entry.startsWith(prefix));
+    if (!line) {
+        throw new Error(`missing_review_line:${prefix}`);
+    }
+    return line.slice(prefix.length).trim();
+}
+function normalizeReviewText(...values) {
+    return values
+        .join(' ')
+        .toLowerCase()
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function parseScores(reviewMessage) {
+    if (/\/5\b/.test(reviewMessage)) {
+        throw new Error('review_scores_must_use_10_point_scale');
+    }
+    const scores = {};
+    for (const criterion of exports.REVIEW_CRITERIA) {
+        const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, 'm');
+        const match = reviewMessage.match(regex);
+        if (!match) {
+            throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
+        }
+        scores[criterion] = Number.parseInt(match[1], 10);
+    }
+    return scores;
+}
+function averageScore(scores) {
+    const values = Object.values(scores);
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function minimumScore(scores) {
+    return Math.min(...Object.values(scores));
+}
+function validateOutcomeAgainstScores(outcome, scores) {
+    const average = averageScore(scores);
+    const minimum = minimumScore(scores);
+    const gameplay = scores['Gameplay / Core Loop'];
+    const controls = scores['Controls / Input'];
+    const ux = scores['UX / Usability'];
+    const ftue = scores['First Time User Experience'];
+    const visuals = scores['Visuals / Art Direction'];
+    const performance = scores['Performance / Stability'];
+    const actual = `actual=average=${average.toFixed(2)},minimum=${minimum},gameplay=${gameplay},controls=${controls},ux=${ux},ftue=${ftue},visuals=${visuals},performance=${performance}`;
+    if (outcome === 'Excellent' && (average < 8.5 || minimum < 7 || gameplay < 8 || controls < 8 || ux < 8 || ftue < 7 || visuals < 8 || performance < 8)) {
+        throw new Error(`excellent_outcome_not_supported_by_scores:requires=average>=8.5,minimum>=7,gameplay>=8,controls>=8,ux>=8,ftue>=7,visuals>=8,performance>=8:${actual}:use_good_or_lower_outcome_unless_scores_are_supported_by_evidence`);
+    }
+    if (outcome === 'Good' && (average < 7.5 || minimum < 6 || gameplay < 7 || controls < 7 || ux < 7 || ftue < 6 || visuals < 7 || performance < 7)) {
+        throw new Error(`good_outcome_not_supported_by_scores:requires=average>=7.5,minimum>=6,gameplay>=7,controls>=7,ux>=7,ftue>=6,visuals>=7,performance>=7:${actual}:use_passed_or_lower_outcome_unless_scores_are_supported_by_evidence`);
+    }
+    if (outcome === 'Passed' && (average < 6 || minimum < 4 || gameplay < 5 || controls < 5 || performance < 5)) {
+        throw new Error(`passed_outcome_not_supported_by_scores:requires=average>=6,minimum>=4,gameplay>=5,controls>=5,performance>=5:${actual}:use_low_quality_or_failed_unless_scores_are_supported_by_evidence`);
+    }
+}
+function validateRequiredEvidenceLines(reviewMessage) {
+    const primaryVerb = requireLine(reviewMessage, 'Primary player verb: ');
+    const primaryEvidence = requireLine(reviewMessage, 'Primary interaction evidence: ');
+    const challengeEvidence = requireLine(reviewMessage, 'Challenge evidence: ');
+    const punchline = requireLine(reviewMessage, 'Punchline assessment: ');
+    const benchmark = requireLine(reviewMessage, 'Comparable benchmark: ');
+    if (primaryVerb.length < 3) {
+        throw new Error('primary_player_verb_too_vague');
+    }
+    if (primaryEvidence.length < 20) {
+        throw new Error('primary_interaction_evidence_too_vague');
+    }
+    if (challengeEvidence.length < 20) {
+        throw new Error('challenge_evidence_too_vague');
+    }
+    if (punchline.length < 8 || punchline.length > 160) {
+        throw new Error('punchline_assessment_invalid_length');
+    }
+    if (benchmark.length < 8) {
+        throw new Error('comparable_benchmark_too_vague');
+    }
+}
+function isNoScoreCaps(scoreCapsApplied) {
+    return scoreCapsApplied.trim().toLowerCase() === 'none';
+}
+function validateCapConsistency(input) {
+    const normalizedText = normalizeReviewText(input.reviewMessage, input.creatorFeedback);
+    const describesZeroChallenge = /\bzero challenge\b|\bno (?:real |meaningful )?challenge\b(?!-)|\bchallenge (?:is )?(?:absent|missing|nonexistent)\b/.test(normalizedText);
+    const describesPrimaryMissing = /\bprimary (?:interaction|verb) (?:is )?(?:absent|missing|unavailable)\b/.test(normalizedText);
+    if (isNoScoreCaps(input.scoreCapsApplied) && (describesZeroChallenge || describesPrimaryMissing)) {
+        const trigger = describesZeroChallenge ? 'zero_or_missing_challenge' : 'primary_interaction_missing';
+        throw new Error(`missing_required_score_cap:${trigger}:score_caps_applied_must_name_the_triggered_cap_or_adjust_the_evidence_wording`);
+    }
+    if (describesZeroChallenge && (['Passed', 'Good', 'Excellent'].includes(input.outcome) || input.scores['Gameplay / Core Loop'] > 3 || input.scores['Depth / Replayability'] > 3)) {
+        throw new Error('gameplay_challenge_absent_score_cap_required');
+    }
+}
+async function assertPngFile(filePath) {
+    const bytes = await node_fs_1.promises.readFile(filePath);
+    if (bytes.length <= 0 || bytes.length > REVIEW_EVIDENCE_MAX_BYTES) {
+        throw new Error(`invalid_review_evidence_size:${filePath}`);
+    }
+    const signature = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+    for (let index = 0; index < signature.length; index += 1) {
+        if (bytes[index] !== signature[index]) {
+            throw new Error(`review_evidence_not_png:${filePath}`);
+        }
+    }
+}
+async function validateGameReviewResult(input) {
+    const normalizedState = String(input.reviewState || '').trim().toUpperCase();
+    if (!TERMINAL_REVIEW_STATES.has(normalizedState)) {
+        return { skipped: true, reason: 'non_terminal_state' };
+    }
+    if (!input.reviewMessage.trim()) {
+        throw new Error('missing_review_message');
+    }
+    const creatorFeedback = input.creatorFeedback ?? '';
+    if (!creatorFeedback.trim()) {
+        throw new Error('missing_creator_feedback');
+    }
+    if (!input.evidenceDir.trim()) {
+        throw new Error('missing_evidence_dir');
+    }
+    const expectedOutcome = STATE_OUTCOME[normalizedState];
+    const actualOutcome = requireLine(input.reviewMessage, 'Outcome: ');
+    if (actualOutcome !== expectedOutcome) {
+        throw new Error(`review_outcome_state_mismatch:${actualOutcome}:${normalizedState}`);
+    }
+    const primarySurface = requireLine(input.reviewMessage, 'Primary reviewed surface: ');
+    if (!['MOBILE_PORTRAIT', 'MOBILE_LANDSCAPE', 'DESKTOP'].includes(primarySurface)) {
+        throw new Error(`invalid_primary_reviewed_surface:${primarySurface}`);
+    }
+    validateRequiredEvidenceLines(input.reviewMessage);
+    const scoreCapsApplied = requireLine(input.reviewMessage, 'Score caps applied: ');
+    if (!creatorFeedback.includes(`Reviewed surface: ${primarySurface}`)) {
+        throw new Error('creator_feedback_missing_reviewed_surface');
+    }
+    const scores = parseScores(input.reviewMessage);
+    validateOutcomeAgainstScores(actualOutcome, scores);
+    validateCapConsistency({
+        creatorFeedback,
+        outcome: actualOutcome,
+        reviewMessage: input.reviewMessage,
+        scoreCapsApplied,
+        scores,
+    });
+    const evidenceDir = resolveFilePath(input.evidenceDir, 'missing_evidence_dir');
+    for (const filename of exports.REQUIRED_REVIEW_EVIDENCE_FILES) {
+        await assertPngFile(node_path_1.default.join(evidenceDir, filename));
+    }
+    return {
+        average: averageScore(scores),
+        evidenceDir,
+        outcome: actualOutcome,
+        primarySurface,
+        scoreCount: Object.keys(scores).length,
+        skipped: false,
+    };
+}
+async function validateReviewResultCommand(options) {
+    const result = await validateGameReviewResult({
+        creatorFeedback: options.creatorFeedbackFile ? await readRequiredTextFile(options.creatorFeedbackFile, 'invalid_creator_feedback_file') : '',
+        evidenceDir: options.evidenceDir,
+        reviewMessage: await readRequiredTextFile(options.messageFile, 'invalid_review_message_file'),
+        reviewState: options.state,
+    });
+    console.log(JSON.stringify(result, null, 2));
+}
+async function resizeForComposite(filePath) {
+    const image = (0, sharp_1.default)(resolveFilePath(filePath, 'invalid_review_evidence_file'));
+    const metadata = await image.metadata();
+    if (!metadata.width || !metadata.height) {
+        throw new Error('invalid_review_evidence_image');
+    }
+    const buffer = await image
+        .resize({ width: 540, height: 960, fit: 'inside', withoutEnlargement: true })
+        .png()
+        .toBuffer();
+    const resizedMetadata = await (0, sharp_1.default)(buffer).metadata();
+    if (!resizedMetadata.width || !resizedMetadata.height) {
+        throw new Error('invalid_review_evidence_image');
+    }
+    return { buffer, width: resizedMetadata.width, height: resizedMetadata.height };
+}
+async function composeReviewEvidence(options) {
+    const entries = [
+        options.core ? { label: 'core', path: options.core } : null,
+        options.win ? { label: 'win', path: options.win } : null,
+        options.loss ? { label: 'loss', path: options.loss } : null,
+    ].filter((entry) => Boolean(entry));
+    if (entries.length === 0) {
+        throw new Error('missing_review_evidence_images');
+    }
+    const images = await Promise.all(entries.map((entry) => resizeForComposite(entry.path)));
+    const padding = 16;
+    const width = images.reduce((sum, image) => sum + image.width, padding * (images.length + 1));
+    const height = Math.max(...images.map((image) => image.height)) + padding * 2;
+    let left = padding;
+    const composites = images.map((image) => {
+        const composite = { input: image.buffer, left, top: padding };
+        left += image.width + padding;
+        return composite;
+    });
+    const outputPath = resolveFilePath(options.out, 'missing_out');
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
+    await (0, sharp_1.default)({
+        create: {
+            width,
+            height,
+            channels: 4,
+            background: { r: 12, g: 12, b: 16, alpha: 1 },
+        },
+    })
+        .composite(composites)
+        .png()
+        .toFile(outputPath);
+    (0, output_1.printSuccess)(`Review evidence composite written to ${outputPath}`);
+    return { outputPath, imageCount: images.length };
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function parseCriterionRating(reviewMessage, criterion) {
+    const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, 'm');
+    const match = reviewMessage.match(regex);
+    if (!match) {
+        throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
+    }
+    return Number.parseInt(match[1], 10);
+}
+function ratingColor(score) {
+    if (score <= 1)
+        return '#ff3b30';
+    if (score <= 4)
+        return '#ff9500';
+    if (score <= 6)
+        return '#ffd60a';
+    if (score <= 9)
+        return '#34c759';
+    return '#bf5af2';
+}
+function outcomeColor(outcome) {
+    if (outcome === 'Blocked')
+        return '#ff3b30';
+    if (outcome === 'Limited')
+        return '#ff9500';
+    if (outcome === 'Passed')
+        return '#ffd60a';
+    if (outcome === 'Good')
+        return '#34c759';
+    if (outcome === 'Excellent')
+        return '#bf5af2';
+    return '#ff9500';
+}
+async function createReviewRatingCard(options) {
+    const reviewMessage = await readRequiredTextFile(options.reviewMessageFile, 'invalid_review_message_file');
+    const outcome = requireLine(reviewMessage, 'Outcome: ');
+    const punchline = (options.punchline?.trim() || requireLine(reviewMessage, 'Punchline assessment: ')).slice(0, 160);
+    const title = (options.title?.trim() || 'Game review ratings').slice(0, 80);
+    const rows = exports.REVIEW_CRITERIA.map((criterion, index) => {
+        const score = parseCriterionRating(reviewMessage, criterion);
+        const x = index < 5 ? 56 : 628;
+        const y = 170 + (index % 5) * 92;
+        return `
+      <rect x="${x}" y="${y}" width="516" height="70" rx="6" fill="#15151c" stroke="#333340"/>
+      <rect x="${x}" y="${y}" width="8" height="70" fill="${ratingColor(score)}"/>
+      <text x="${x + 24}" y="${y + 42}" fill="#f5f5f7" font-size="22" font-weight="700">${escapeXml(criterion)}</text>
+      <text x="${x + 448}" y="${y + 44}" fill="${ratingColor(score)}" font-size="32" font-weight="800" text-anchor="end">${score}/10</text>
+    `;
+    }).join('');
+    const svg = `
+    <svg width="1200" height="760" xmlns="http://www.w3.org/2000/svg">
+      <rect width="1200" height="760" fill="#000"/>
+      <text x="56" y="82" fill="#fff" font-size="38" font-weight="800">${escapeXml(title)}</text>
+      <text x="1144" y="82" fill="${outcomeColor(outcome)}" font-size="30" font-weight="800" text-anchor="end">${escapeXml(outcome)}</text>
+      <line x1="56" y1="122" x2="1144" y2="122" stroke="#333340"/>
+      ${rows}
+      <line x1="56" y1="650" x2="1144" y2="650" stroke="#333340"/>
+      <text x="600" y="708" fill="${outcomeColor(outcome)}" font-size="32" font-weight="800" text-anchor="middle">${escapeXml(punchline)}</text>
+    </svg>
+  `;
+    const outputPath = resolveFilePath(options.out, 'missing_out');
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
+    await (0, sharp_1.default)(Buffer.from(svg)).png().toFile(outputPath);
+    (0, output_1.printSuccess)(`Review rating card written to ${outputPath}`);
+    return { outputPath, width: 1200, height: 760 };
+}

package/dist/commands/validate.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = validate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
 const types_2 = require("@playdrop/types");
 const commandContext_1 = require("../commandContext");
@@ -12,6 +14,66 @@ const assetSpecs_1 = require("../assetSpecs");
 const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
 const dev_1 = require("./dev");
 const upload_content_1 = require("./upload-content");
+function normalizePositivePort(value) {
+    const parsed = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
+    return Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : null;
+}
+function findWorkspaceMetadataFile(startPath) {
+    let current = (0, node_path_1.resolve)(startPath);
+    if ((0, node_fs_1.existsSync)(current) && (0, node_fs_1.statSync)(current).isFile()) {
+        current = (0, node_path_1.dirname)(current);
+    }
+    while (true) {
+        const workspacePinPath = (0, node_path_1.join)(current, '.playdrop.json');
+        if ((0, node_fs_1.existsSync)(workspacePinPath) && (0, node_fs_1.statSync)(workspacePinPath).isFile()) {
+            return workspacePinPath;
+        }
+        const taskContextPath = (0, node_path_1.join)(current, '.playdrop', 'task.json');
+        if ((0, node_fs_1.existsSync)(taskContextPath) && (0, node_fs_1.statSync)(taskContextPath).isFile()) {
+            return taskContextPath;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function readTaskScopedDevRouterPort(workspacePath) {
+    const metadataPath = findWorkspaceMetadataFile(workspacePath);
+    if (!metadataPath) {
+        throw new Error('project_validate_task_dev_port_missing');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(metadataPath, 'utf8'));
+    }
+    catch {
+        throw new Error(`project_validate_task_dev_port_invalid_json:${metadataPath}`);
+    }
+    const port = normalizePositivePort(parsed?.devPort);
+    if (!port) {
+        throw new Error(`project_validate_task_dev_port_missing:${metadataPath}`);
+    }
+    return { file: metadataPath, port };
+}
+function resolveValidationDevRouterPort(workspacePath, taskScoped) {
+    if (!taskScoped) {
+        return (0, dev_1.resolveDevRouterPort)(process.env.PLAYDROP_DEV_ROUTER_PORT);
+    }
+    const taskPort = readTaskScopedDevRouterPort(workspacePath);
+    const envPortRaw = process.env.PLAYDROP_DEV_ROUTER_PORT;
+    if (envPortRaw !== undefined && envPortRaw.trim()) {
+        const envPort = normalizePositivePort(envPortRaw);
+        if (!envPort) {
+            throw new Error(`project_validate_env_dev_port_invalid:${envPortRaw}`);
+        }
+        if (envPort !== taskPort.port) {
+            throw new Error(`project_validate_worker_dev_port_mismatch:env=${envPort}:task=${taskPort.port}:${taskPort.file}`);
+        }
+    }
+    return taskPort.port;
+}
 function buildLocalAssetSpecLookups(tasks) {
     const exactByRef = new Map();
     const uniqueByNameVersion = new Map();
@@ -115,7 +177,7 @@ async function loadHostedLaunchValidationContext(workspacePath, envOverride) {
         apiBase: ctx.envConfig.apiBase,
         webBase: ctx.envConfig.webBase ?? null,
         token: ctx.token,
-        devRouterPort: (0, dev_1.resolveDevRouterPort)(process.env.PLAYDROP_DEV_ROUTER_PORT),
+        devRouterPort: resolveValidationDevRouterPort(workspacePath, Boolean(ctx.workspaceAuth?.config.taskToken)),
         taskScoped: Boolean(ctx.workspaceAuth?.config.taskToken),
     };
 }

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

@@ -9,14 +9,25 @@ export type LoggedProcessResult = {
     stderr: string;
     outputTail: string;
     timedOut: boolean;
+    tokenUsage: AgentTokenUsage;
     tokensUsed: number | null;
 };
+export type AgentTokenUsage = {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheCreationInputTokens: number | null;
+    cacheReadInputTokens: number | null;
+    totalTokens: number | null;
+    rawProviderUsage: Record<string, unknown> | null;
+    usageParseError: string | null;
+};
 export type LoggedProcessTranscriptChunk = {
     stream: 'stdout' | 'stderr';
     content: string;
 };
 export declare function readPositiveEnvInt(name: string, fallback: number): number;
 export declare function readEnvBoolean(name: string, fallback: boolean): boolean;
+export declare function extractAgentTokenUsage(output: string): AgentTokenUsage;
 export declare function extractCodexTokensUsed(output: string): number | null;
 export declare function assertWorkerTokenUsageWithinCap(input: {
     tokensUsed: number | null;
@@ -62,6 +73,7 @@ export declare function buildClaudeDeniedPermissionRules(denyReadRoots?: string[
 export declare function buildWorkerChildEnv(input: {
     binDir: string;
     taskId: number;
+    attempt: number;
     envName: string;
     eventDir?: string;
     devPort?: number;

package/dist/commands/worker/runtime.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = exports.DEFAULT_CODEX_LOG_TAIL_CHARS = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
 exports.readPositiveEnvInt = readPositiveEnvInt;
 exports.readEnvBoolean = readEnvBoolean;
+exports.extractAgentTokenUsage = extractAgentTokenUsage;
 exports.extractCodexTokensUsed = extractCodexTokensUsed;
 exports.assertWorkerTokenUsageWithinCap = assertWorkerTokenUsageWithinCap;
 exports.runLoggedProcess = runLoggedProcess;
@@ -52,7 +53,45 @@ function readEnvBoolean(name, fallback) {
     }
     throw new Error(`invalid_${name.toLowerCase()}`);
 }
-function extractCodexTokensUsed(output) {
+function normalizeTokenCount(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return null;
+    }
+    return Math.ceil(value);
+}
+function coerceRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function readStructuredUsage(parsed) {
+    const root = coerceRecord(parsed);
+    if (!root) {
+        return null;
+    }
+    const directUsage = coerceRecord(root.usage);
+    if (directUsage) {
+        return directUsage;
+    }
+    const message = coerceRecord(root.message);
+    const messageUsage = coerceRecord(message?.usage);
+    if (messageUsage) {
+        return messageUsage;
+    }
+    const event = coerceRecord(root.event);
+    const eventUsage = coerceRecord(event?.usage);
+    if (eventUsage) {
+        return eventUsage;
+    }
+    const eventMessage = coerceRecord(event?.message);
+    const eventMessageUsage = coerceRecord(eventMessage?.usage);
+    if (eventMessageUsage) {
+        return eventMessageUsage;
+    }
+    return null;
+}
+function extractAgentTokenUsage(output) {
     for (const line of output.split(/\r?\n/).reverse()) {
         const trimmed = line.trim();
         if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
@@ -60,50 +99,49 @@ function extractCodexTokensUsed(output) {
         }
         try {
             const parsed = JSON.parse(trimmed);
-            const usage = parsed.usage;
+            const usage = readStructuredUsage(parsed);
             if (!usage) {
                 continue;
             }
-            const tokenKeys = [
-                'input_tokens',
-                'output_tokens',
-                'cache_creation_input_tokens',
-                'cache_read_input_tokens',
+            const inputTokens = normalizeTokenCount(usage.input_tokens);
+            const outputTokens = normalizeTokenCount(usage.output_tokens);
+            const cacheCreationInputTokens = normalizeTokenCount(usage.cache_creation_input_tokens);
+            const cacheReadInputTokens = normalizeTokenCount(usage.cache_read_input_tokens);
+            const tokenParts = [
+                inputTokens,
+                outputTokens,
+                cacheCreationInputTokens,
+                cacheReadInputTokens,
             ];
-            let total = 0;
-            let sawTokenValue = false;
-            for (const key of tokenKeys) {
-                const value = usage[key];
-                if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-                    continue;
-                }
-                total += value;
-                sawTokenValue = true;
-            }
+            const sawTokenValue = tokenParts.some((value) => value !== null);
             if (sawTokenValue) {
-                return Math.ceil(total);
+                return {
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationInputTokens,
+                    cacheReadInputTokens,
+                    totalTokens: tokenParts.reduce((sum, value) => sum + (value ?? 0), 0),
+                    rawProviderUsage: usage,
+                    usageParseError: null,
+                };
             }
         }
         catch {
-            // Fall through to the plain-text patterns below.
-        }
-    }
-    const patterns = [
-        /total\s+tokens\s*:?\s*([\d,]+)/i,
-        /tokens\s+used\s*:?\s*([\d,]+)/i,
-        /"total_tokens"\s*:\s*([\d,]+)/i,
-    ];
-    for (const pattern of patterns) {
-        const match = pattern.exec(output);
-        if (!match?.[1]) {
             continue;
         }
-        const parsed = Number.parseInt(match[1].replace(/,/g, ''), 10);
-        if (Number.isInteger(parsed) && parsed >= 0) {
-            return parsed;
-        }
     }
-    return null;
+    return {
+        inputTokens: null,
+        outputTokens: null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: null,
+        totalTokens: null,
+        rawProviderUsage: null,
+        usageParseError: 'agent_usage_not_reported',
+    };
+}
+function extractCodexTokensUsed(output) {
+    return extractAgentTokenUsage(output).totalTokens;
 }
 function assertWorkerTokenUsageWithinCap(input) {
     if (input.tokensUsed === null) {
@@ -228,6 +266,7 @@ async function runLoggedProcess(input) {
                     throw transcriptFlushError;
                 }
                 const outputTail = tailText(combined, input.maxOutputChars);
+                const tokenUsage = extractAgentTokenUsage(`${stdout}\n${stderr}\n${outputTail}`);
                 resolve({
                     exitCode: code,
                     signal,
@@ -235,7 +274,8 @@ async function runLoggedProcess(input) {
                     stderr,
                     outputTail,
                     timedOut,
-                    tokensUsed: extractCodexTokensUsed(`${stdout}\n${stderr}\n${outputTail}`),
+                    tokenUsage,
+                    tokensUsed: tokenUsage.totalTokens,
                 });
             })().catch(reject);
         });
@@ -399,7 +439,11 @@ function buildWorkerChildEnv(input) {
         }
     }
     child.PLAYDROP_WORKER_CONTEXT = '1';
+    if (!Number.isInteger(input.attempt) || input.attempt <= 0) {
+        throw new Error('invalid_worker_task_attempt');
+    }
     child.PLAYDROP_WORKER_TASK_ID = String(input.taskId);
+    child.PLAYDROP_WORKER_TASK_ATTEMPT = String(input.attempt);
     if (input.devPort !== undefined) {
         if (!Number.isInteger(input.devPort) || input.devPort <= 0 || input.devPort > 65535) {
             throw new Error('invalid_worker_task_dev_port');