@playdrop/playdrop-cli 0.10.17 → 0.10.19

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.extractAgentTokenUsage = 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.readCodexRolloutTokenUsageForThread = exports.readCodexSandboxMode = exports.readEnvBoolean = exports.extractCodexTokensUsed = exports.extractCodexThreadId = exports.extractCodexRolloutTokenUsage = 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;
@@ -13,6 +13,7 @@ exports.claimBackoffDelayMs = claimBackoffDelayMs;
 exports.resolveWorkerHomeDir = resolveWorkerHomeDir;
 exports.hasAgentTaskUploadedArtifact = hasAgentTaskUploadedArtifact;
 exports.appendWorkerTranscriptChunks = appendWorkerTranscriptChunks;
+exports.readTaskNextStepsFile = readTaskNextStepsFile;
 exports.assertTaskUploadResultMatchesContext = assertTaskUploadResultMatchesContext;
 exports.stageAssignmentWorkspaceFiles = stageAssignmentWorkspaceFiles;
 exports.resolvePlaydropPluginRoot = resolvePlaydropPluginRoot;
@@ -22,6 +23,8 @@ exports.readWorkerTaskState = readWorkerTaskState;
 exports.buildWorkerHealthAlertText = buildWorkerHealthAlertText;
 exports.isWorkerAuthFailureError = isWorkerAuthFailureError;
 exports.classifyWorkerEventDrainError = classifyWorkerEventDrainError;
+exports.isWorkerTransientNetworkError = isWorkerTransientNetworkError;
+exports.classifyWorkerHeartbeatError = classifyWorkerHeartbeatError;
 exports.assertWorkerClaimErrorRetryable = assertWorkerClaimErrorRetryable;
 exports.resolvePlaydropAssetRequirementFromText = resolvePlaydropAssetRequirementFromText;
 exports.loadWorkerEnvFile = loadWorkerEnvFile;
@@ -44,6 +47,7 @@ exports.startWorker = startWorker;
 exports.reportTask = reportTask;
 exports.reportCatalogueTask = reportCatalogueTask;
 exports.uploadTask = uploadTask;
+exports.claimSlugTask = claimSlugTask;
 exports.completeTask = completeTask;
 exports.readReviewEvidenceFiles = readReviewEvidenceFiles;
 exports.submitReviewTask = submitReviewTask;
@@ -75,12 +79,16 @@ Object.defineProperty(exports, "buildClaudeExecArgs", { enumerable: true, get: f
 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, "extractCodexRolloutTokenUsage", { enumerable: true, get: function () { return runtime_2.extractCodexRolloutTokenUsage; } });
+Object.defineProperty(exports, "extractCodexThreadId", { enumerable: true, get: function () { return runtime_2.extractCodexThreadId; } });
 Object.defineProperty(exports, "extractCodexTokensUsed", { enumerable: true, get: function () { return runtime_2.extractCodexTokensUsed; } });
 Object.defineProperty(exports, "readEnvBoolean", { enumerable: true, get: function () { return runtime_2.readEnvBoolean; } });
 Object.defineProperty(exports, "readCodexSandboxMode", { enumerable: true, get: function () { return runtime_2.readCodexSandboxMode; } });
+Object.defineProperty(exports, "readCodexRolloutTokenUsageForThread", { enumerable: true, get: function () { return runtime_2.readCodexRolloutTokenUsageForThread; } });
 Object.defineProperty(exports, "runLoggedProcess", { enumerable: true, get: function () { return runtime_2.runLoggedProcess; } });
 const DEFAULT_POLL_INTERVAL_MS = 1000;
 const HEARTBEAT_INTERVAL_MS = 10000;
+const TASK_HEARTBEAT_TRANSIENT_FAILURE_LIMIT = 6;
 const DEFAULT_WORKER_MAX_PARALLEL_TASKS = 5;
 const DEFAULT_WORKER_DEV_PORT_BASE = 8900;
 const CLAIM_BACKOFF_BASE_MS = 1000;
@@ -92,67 +100,13 @@ const SLACK_API_BASE_URL = 'https://slack.com/api';
 const WORKER_WRAPPER_CONTRACT_VERSION = 1;
 const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'REMIX_GAME', 'GAME_UPDATE', 'GAME_REVIEW'];
 const requireFromWorker = (0, node_module_1.createRequire)(__filename);
-const PLAYDROP_PLUGIN_DAEMON_GAME_CREATION_SKILL_PATH = 'skills/daemon-game-creation/SKILL.md';
-const PLAYDROP_PLUGIN_GAME_IMPROVEMENT_SKILL_PATH = 'skills/game-improvement/SKILL.md';
-const PLAYDROP_PLUGIN_ASSET_DISCOVERY_SKILL_PATH = 'skills/asset-discovery/SKILL.md';
-const PLAYDROP_PLUGIN_ASSET_EXTRACTION_SKILL_PATH = 'skills/asset-extraction-2d/SKILL.md';
-const PLAYDROP_PLUGIN_LISTING_ART_SKILL_PATH = 'skills/listing-art/SKILL.md';
-const PLAYDROP_PLUGIN_GAME_REVIEW_SKILL_PATH = 'skills/game-review/SKILL.md';
-const PLAYDROP_PLUGIN_ASSET_REUSE_REFERENCE_PATH = 'references/asset-reuse.md';
-const PLAYDROP_PLUGIN_ASSETS_AND_GENERATION_REFERENCE_PATH = 'references/assets-and-generation.md';
-const PLAYDROP_PLUGIN_CODE_REUSE_REFERENCE_PATH = 'references/code-reuse.md';
-const PLAYDROP_PLUGIN_EXTRACTOR_PATH = 'scripts/extract-alpha-background-swap.ts';
-const PLAYDROP_PLUGIN_LISTING_ICON_SCRIPT_PATH = 'scripts/compose-listing-icon.ts';
-const PLAYDROP_PLUGIN_LISTING_TITLE_SCRIPT_PATH = 'scripts/compose-listing-title.ts';
 const STAGED_PLAYDROP_PLUGIN_ROOT = '.playdrop/plugin';
-const PLAYDROP_PLUGIN_CREATION_REFERENCE_FILES = [
-    PLAYDROP_PLUGIN_DAEMON_GAME_CREATION_SKILL_PATH,
-    PLAYDROP_PLUGIN_GAME_IMPROVEMENT_SKILL_PATH,
-    PLAYDROP_PLUGIN_ASSET_DISCOVERY_SKILL_PATH,
-    PLAYDROP_PLUGIN_ASSET_EXTRACTION_SKILL_PATH,
-    PLAYDROP_PLUGIN_LISTING_ART_SKILL_PATH,
-    PLAYDROP_PLUGIN_ASSET_REUSE_REFERENCE_PATH,
-    PLAYDROP_PLUGIN_ASSETS_AND_GENERATION_REFERENCE_PATH,
-    PLAYDROP_PLUGIN_CODE_REUSE_REFERENCE_PATH,
-    PLAYDROP_PLUGIN_EXTRACTOR_PATH,
-    PLAYDROP_PLUGIN_LISTING_ICON_SCRIPT_PATH,
-    PLAYDROP_PLUGIN_LISTING_TITLE_SCRIPT_PATH,
-];
-const PLAYDROP_PLUGIN_GAME_REVIEW_REFERENCE_FILES = [
-    PLAYDROP_PLUGIN_GAME_REVIEW_SKILL_PATH,
-    'references/game-review-criteria.md',
-    'references/game-review-comparative-method.md',
-    'references/game-review-evidence-capture.md',
-    'references/game-review-rating-scale.md',
-    'references/game-review-score-caps.md',
-    'references/game-review-gates.md',
-    'references/game-review-gates/concept.md',
-    'references/game-review-gates/gameplay-prototype.md',
-    'references/game-review-gates/demo.md',
-    'references/game-review-gates/vertical-slice.md',
-    'references/game-review-gates/first-release.md',
-    'references/game-review-gates/mature-live-version.md',
-    'references/game-review-outcomes.md',
-    'references/game-review-feedback-format.md',
-    'references/game-review-dimensions/gameplay-core-loop.md',
-    'references/game-review-dimensions/depth-replayability.md',
-    'references/game-review-dimensions/controls-input.md',
-    'references/game-review-dimensions/ux-usability.md',
-    'references/game-review-dimensions/first-time-user-experience.md',
-    'references/game-review-dimensions/visuals-art-direction.md',
-    'references/game-review-dimensions/audio-feedback.md',
-    'references/game-review-dimensions/store-listing-metadata-accuracy.md',
-    'references/game-review-dimensions/safety-age-rating-compliance.md',
-    'references/game-review-dimensions/performance-stability.md',
-];
-const PLAYDROP_PLUGIN_REFERENCE_FILES = [
-    ...PLAYDROP_PLUGIN_CREATION_REFERENCE_FILES,
-    ...PLAYDROP_PLUGIN_GAME_REVIEW_REFERENCE_FILES,
-];
+const PLAYDROP_PLUGIN_STAGING_MANIFEST_PATH = 'playdrop-worker-staging.json';
 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', 'claim-slug'],
     ['task', 'upload'],
     ['task', 'done'],
     ['task', 'submit-review'],
@@ -175,7 +129,7 @@ const WORKER_CONTEXT_ALLOWED_COMMANDS = [
     ['ai', 'jobs', 'detail'],
     ['ai', 'generations'],
 ];
-exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = 'worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task upload/done/fail, assigned remix scaffolding, project validation/build/dev/capture, read-only catalogue/documentation lookup, and PlayDrop AI generation are permitted.';
+exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = 'worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/capture, read-only catalogue/documentation lookup, and PlayDrop AI generation are permitted.';
 function allocateWorkerDevPort(input) {
     const basePort = input.basePort ?? DEFAULT_WORKER_DEV_PORT_BASE;
     const maxParallelTasks = input.maxParallelTasks ?? DEFAULT_WORKER_MAX_PARALLEL_TASKS;
@@ -203,7 +157,7 @@ function isWorkerContextCommandAllowed(argv) {
     if (WORKER_CONTEXT_ALLOWED_COMMANDS.some((allowed) => allowed.every((part, index) => argv[index] === part))) {
         return true;
     }
-    return isAssignedRemixScaffoldCommandAllowed(argv);
+    return isAssignedAppScaffoldCommandAllowed(argv);
 }
 function readWorkerContextForPolicy() {
     try {
@@ -227,7 +181,7 @@ function normalizeRemixFlagValue(argv) {
     }
     return null;
 }
-function isAssignedRemixScaffoldCommandAllowed(argv) {
+function isAssignedAppScaffoldCommandAllowed(argv) {
     if (argv[0] !== 'project' || argv[1] !== 'create' || argv[2] !== 'app') {
         return false;
     }
@@ -239,7 +193,12 @@ function isAssignedRemixScaffoldCommandAllowed(argv) {
     if (context?.kind !== 'REMIX_GAME'
         || !context.outputAppName
         || requestedAppName !== context.outputAppName) {
-        return false;
+        if (context?.kind !== 'NEW_GAME'
+            || !context.outputAppName
+            || requestedAppName !== context.outputAppName) {
+            return false;
+        }
+        return normalizeRemixFlagValue(argv) === null;
     }
     return normalizeRemixFlagValue(argv) === context.remixSourceRef;
 }
@@ -465,6 +424,9 @@ async function stageWorkerTaskContext(input) {
         taskToken: input.taskContext.taskToken,
     }, null, 2), 'utf8');
 }
+async function writeWorkerTaskContextFile(workspaceDir, taskContext) {
+    await (0, promises_1.writeFile)(workerTaskContextPath(workspaceDir), JSON.stringify(taskContext, null, 2), 'utf8');
+}
 function findWorkspaceTaskFile(startDir, basename) {
     let current = node_path_1.default.resolve(startDir);
     while (true) {
@@ -598,6 +560,122 @@ function readTaskUploadResultFile(startDir = node_process_1.default.cwd()) {
     }
     return { taskId, appId, appVersionId, appName, version, versionNodeId, creatorUsername };
 }
+const AGENT_TASK_NEXT_STEP_CATEGORY_SET = new Set(types_1.AGENT_TASK_NEXT_STEP_CATEGORIES);
+const AGENT_TASK_CLAIM_SLUG_REGEX = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+const NEXT_STEPS_SCHEMA_HELP = [
+    'Expected next-steps.json format:',
+    '{"nextSteps":[{"id":"tune-difficulty","title":"Tune difficulty","description":"Make the opening easier and add a sharper ramp.","prompt":"Tune the game difficulty so the first minute is approachable and the second minute becomes harder.","category":"MECHANICS"}]}',
+    `Allowed categories: ${types_1.AGENT_TASK_NEXT_STEP_CATEGORIES.join(', ')}`,
+];
+const NEXT_STEPS_READ_FAILED = Symbol('NEXT_STEPS_READ_FAILED');
+function normalizeTaskClaimSlugAppName(value) {
+    const appName = typeof value === 'string' ? value.trim() : '';
+    if (!appName || appName.length > 128 || !AGENT_TASK_CLAIM_SLUG_REGEX.test(appName)) {
+        throw new Error('invalid_slug_format');
+    }
+    return appName;
+}
+function normalizeTaskClaimSlugDisplayName(value) {
+    const displayName = typeof value === 'string' ? value.trim() : '';
+    if (!displayName || displayName.length > 120) {
+        throw new Error('invalid_display_name');
+    }
+    return displayName;
+}
+function readTaskNextStepsFile(filePath) {
+    const normalizedPath = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalizedPath) {
+        return undefined;
+    }
+    const resolved = node_path_1.default.resolve(normalizedPath);
+    if (!(0, node_fs_1.existsSync)(resolved)) {
+        throw new Error('invalid_agent_task_next_steps_file');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(resolved, 'utf8'));
+    }
+    catch {
+        throw new Error('invalid_agent_task_next_steps_file');
+    }
+    let rawSteps = null;
+    if (Array.isArray(parsed)) {
+        rawSteps = parsed;
+    }
+    else if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        const object = parsed;
+        if (Array.isArray(object['nextSteps'])) {
+            rawSteps = object['nextSteps'];
+        }
+    }
+    if (!rawSteps) {
+        throw new Error('invalid_agent_task_next_steps');
+    }
+    if (rawSteps.length > 3) {
+        throw new Error('invalid_agent_task_next_steps_count');
+    }
+    const ids = new Set();
+    return rawSteps.map((entry) => {
+        const object = entry && typeof entry === 'object' && !Array.isArray(entry)
+            ? entry
+            : null;
+        if (!object) {
+            throw new Error('invalid_agent_task_next_step');
+        }
+        const id = typeof object['id'] === 'string' ? object['id'].trim() : '';
+        if (!id || id.length > 64 || !types_1.AGENT_TASK_NEXT_STEP_ID_REGEX.test(id)) {
+            throw new Error('invalid_agent_task_next_step_id');
+        }
+        if (ids.has(id)) {
+            throw new Error('invalid_agent_task_next_step_id_duplicate');
+        }
+        ids.add(id);
+        const title = typeof object['title'] === 'string' ? object['title'].trim() : '';
+        if (!title || title.length > 120) {
+            throw new Error('invalid_agent_task_next_step_title');
+        }
+        const description = typeof object['description'] === 'string' ? object['description'].trim() : '';
+        if (!description || description.length > 400) {
+            throw new Error('invalid_agent_task_next_step_description');
+        }
+        const prompt = typeof object['prompt'] === 'string' ? object['prompt'].trim() : '';
+        if (!prompt || prompt.length > 1200) {
+            throw new Error('invalid_agent_task_next_step_prompt');
+        }
+        const category = typeof object['category'] === 'string' ? object['category'].trim() : '';
+        if (!AGENT_TASK_NEXT_STEP_CATEGORY_SET.has(category)) {
+            throw new Error('invalid_agent_task_next_step_category');
+        }
+        return { id, title, description, prompt, category: category };
+    });
+}
+async function recordRejectedNextStepsFile(input) {
+    if (!input.ctx) {
+        return;
+    }
+    await input.ctx.client.workerCreateAgentTaskEvent(input.taskContext.taskId, {
+        taskToken: input.taskContext.taskToken,
+        kind: 'progress',
+        phase: 'next-steps',
+        message: `Rejected next-steps.json: ${input.code}`,
+    });
+}
+async function readTaskNextStepsFileForCommand(input) {
+    try {
+        return readTaskNextStepsFile(input.filePath);
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.message : String(error);
+        await recordRejectedNextStepsFile({
+            ctx: input.ctx,
+            taskContext: input.taskContext,
+            code,
+        });
+        (0, messages_1.printErrorWithHelp)(code, NEXT_STEPS_SCHEMA_HELP, { command: input.command });
+        node_process_1.default.exitCode = 1;
+        return NEXT_STEPS_READ_FAILED;
+    }
+}
 function assertTaskUploadResultMatchesContext(input) {
     if (input.uploadResult.taskId !== input.taskContext.taskId) {
         throw new Error('task_upload_result_task_mismatch');
@@ -693,8 +771,97 @@ function candidateVersionDirectories(root) {
         .sort((left, right) => right.localeCompare(left, undefined, { numeric: true }))
         .map((name) => node_path_1.default.join(root, name));
 }
-function hasPlaydropPluginReferences(pluginRoot) {
-    return PLAYDROP_PLUGIN_REFERENCE_FILES.every((relativePath) => (0, node_fs_1.existsSync)(node_path_1.default.join(pluginRoot, relativePath)));
+function isDirectory(candidatePath) {
+    try {
+        return (0, node_fs_1.statSync)(candidatePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isFile(candidatePath) {
+    try {
+        return (0, node_fs_1.statSync)(candidatePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikePlaydropPluginRoot(pluginRoot) {
+    return isDirectory(pluginRoot) && ((0, node_fs_1.existsSync)(node_path_1.default.join(pluginRoot, PLAYDROP_PLUGIN_STAGING_MANIFEST_PATH))
+        || isDirectory(node_path_1.default.join(pluginRoot, 'skills'))
+        || isFile(node_path_1.default.join(pluginRoot, '.codex-plugin', 'plugin.json'))
+        || isFile(node_path_1.default.join(pluginRoot, '.claude-plugin', 'plugin.json'))
+        || isFile(node_path_1.default.join(pluginRoot, '.cursor-plugin', 'plugin.json')));
+}
+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 WORKER_SUPPORTED_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;
+    }
+    return {
+        version: 1,
+        taskFiles,
+    };
 }
 function resolvePlaydropPluginRoot(input = {}) {
     const homeDir = input.homeDir ?? node_os_1.default.homedir();
@@ -702,9 +869,7 @@ function resolvePlaydropPluginRoot(input = {}) {
     const explicitRoot = env.PLAYDROP_WORKER_PLAYDROP_PLUGIN_DIR?.trim();
     if (explicitRoot) {
         const resolved = node_path_1.default.resolve(explicitRoot);
-        if (!hasPlaydropPluginReferences(resolved)) {
-            throw new Error(`playdrop_plugin_reference_missing: expected PlayDrop plugin skills and scripts under ${resolved}`);
-        }
+        readPlaydropPluginStagingManifest(resolved);
         return resolved;
     }
     const candidates = [
@@ -716,27 +881,22 @@ function resolvePlaydropPluginRoot(input = {}) {
         ...candidateVersionDirectories(node_path_1.default.join(homeDir, '.codex', 'plugins', 'cache', 'playdrop', 'playdrop')),
         ...candidateVersionDirectories(node_path_1.default.join(homeDir, '.codex', 'plugins', 'cache', 'olivier-local-plugins', 'playdrop')),
     ];
-    const pluginRoot = candidates.find(hasPlaydropPluginReferences);
-    if (!pluginRoot) {
-        throw new Error('playdrop_plugin_reference_missing: install or update the PlayDrop plugin so the required skills and scripts are available.');
+    for (const candidate of candidates) {
+        if (!looksLikePlaydropPluginRoot(candidate)) {
+            continue;
+        }
+        readPlaydropPluginStagingManifest(candidate);
+        return candidate;
     }
-    return pluginRoot;
+    throw new Error(`playdrop_plugin_staging_manifest_missing: install or update the PlayDrop plugin so ${PLAYDROP_PLUGIN_STAGING_MANIFEST_PATH} is available.`);
 }
 async function stagePlaydropPluginReferences(input) {
     const pluginRoot = node_path_1.default.resolve(input.pluginRoot);
-    if (!hasPlaydropPluginReferences(pluginRoot)) {
-        throw new Error(`playdrop_plugin_reference_missing: expected required PlayDrop plugin skills and scripts under ${pluginRoot}`);
-    }
-    let referenceFiles;
-    if (input.kind === 'GAME_REVIEW') {
-        referenceFiles = PLAYDROP_PLUGIN_GAME_REVIEW_REFERENCE_FILES;
-    }
-    else if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME' || input.kind === 'GAME_UPDATE') {
-        referenceFiles = PLAYDROP_PLUGIN_CREATION_REFERENCE_FILES;
-    }
-    else {
+    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];
     const staged = [];
     for (const relativePath of referenceFiles) {
         const destinationRelativePath = node_path_1.default.join(STAGED_PLAYDROP_PLUGIN_ROOT, relativePath);
@@ -930,6 +1090,38 @@ function classifyWorkerEventDrainError(error) {
     }
     return null;
 }
+function readErrorCauseCode(error) {
+    const cause = error instanceof Error ? error.cause : null;
+    if (cause && typeof cause === 'object' && 'code' in cause && typeof cause.code === 'string') {
+        return cause.code;
+    }
+    return null;
+}
+function isWorkerTransientNetworkError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes('fetch failed') || message.includes('socket hang up')) {
+        return true;
+    }
+    const causeCode = readErrorCauseCode(error);
+    return causeCode
+        ? ['ECONNRESET', 'ECONNREFUSED', 'EPIPE', 'ETIMEDOUT', 'UND_ERR_CONNECT_TIMEOUT'].includes(causeCode)
+        : false;
+}
+function classifyWorkerHeartbeatError(error) {
+    if (isWorkerAuthFailureError(error)) {
+        return 'session_expired';
+    }
+    if (isLeaseInvalidError(error)) {
+        return 'lease_invalid';
+    }
+    if (isWorkerTransientNetworkError(error)) {
+        return 'transient_network';
+    }
+    return null;
+}
 // Throws for claim errors that must stop the worker; returns for transient
 // errors the claim loop may retry with backoff.
 function assertWorkerClaimErrorRetryable(error) {
@@ -1349,10 +1541,15 @@ function normalizeQueuedWorkerEvent(value) {
     if (!kind) {
         throw new Error('agent_task_worker_event_kind_invalid');
     }
-    const message = typeof object.message === 'string' ? object.message.trim() : '';
-    if (!message) {
-        throw new Error('agent_task_worker_event_message_missing');
-    }
+    const message = typeof object.message === 'string' && object.message.trim()
+        ? object.message.trim()
+        : null;
+    const done = typeof object.done === 'string' && object.done.trim()
+        ? object.done.trim()
+        : null;
+    const current = typeof object.current === 'string' && object.current.trim()
+        ? object.current.trim()
+        : null;
     const phase = typeof object.phase === 'string' && object.phase.trim()
         ? object.phase.trim()
         : null;
@@ -1365,10 +1562,16 @@ function normalizeQueuedWorkerEvent(value) {
     if (kind === 'catalogue_preview' && !payload) {
         throw new Error('agent_task_worker_event_payload_missing');
     }
+    if (kind === 'catalogue_preview' && !message) {
+        throw new Error('agent_task_worker_event_message_missing');
+    }
+    if (kind === 'progress' && !message && !done && !current) {
+        throw new Error('agent_task_worker_event_message_missing');
+    }
     if (kind === 'progress') {
-        return { kind, phase, message, pct };
+        return { kind, phase, message, done, current, pct };
     }
-    return { kind, phase, message, pct, payload };
+    return { kind, phase, message, done, current, pct, payload };
 }
 async function drainWorkerEventQueue(input) {
     if (!(0, node_fs_1.existsSync)(input.eventDir)) {
@@ -1386,8 +1589,10 @@ async function drainWorkerEventQueue(input) {
             leaseToken: input.leaseToken,
             kind: event.kind,
             phase: event.phase,
-            message: event.message,
-            pct: event.pct,
+            ...(event.message ? { message: event.message } : {}),
+            ...(event.done ? { done: event.done } : {}),
+            ...(event.current ? { current: event.current } : {}),
+            ...(event.pct !== null && event.pct !== undefined ? { pct: event.pct } : {}),
             ...(event.payload ? { payload: event.payload } : {}),
         });
         (0, node_fs_1.rmSync)(filePath, { force: true });
@@ -1443,7 +1648,9 @@ function resolveClaudeRuntimeModel(model) {
     return model;
 }
 async function runCodex(input) {
-    return await (0, runtime_1.runLoggedProcess)({
+    let observedCodexThreadId = null;
+    let codexThreadProbe = '';
+    const result = await (0, runtime_1.runLoggedProcess)({
         command: 'codex',
         args: (0, runtime_1.buildCodexExecArgs)({
             workspaceDir: input.workspaceDir,
@@ -1464,10 +1671,41 @@ async function runCodex(input) {
         stdin: input.prompt,
         timeoutMs: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_CODEX_TIMEOUT_MS', runtime_1.DEFAULT_CODEX_TIMEOUT_MS),
         maxOutputChars: runtime_1.DEFAULT_CODEX_LOG_TAIL_CHARS,
-        onTranscriptChunks: input.onTranscriptChunks,
+        onTranscriptChunks: async (chunks) => {
+            if (!observedCodexThreadId) {
+                codexThreadProbe = (codexThreadProbe + chunks.map((chunk) => chunk.content).join('')).slice(-64000);
+                observedCodexThreadId = (0, runtime_1.extractCodexThreadId)(codexThreadProbe);
+            }
+            await input.onTranscriptChunks(chunks);
+        },
         transcriptFlushIntervalMs: runtime_1.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS,
         onChild: input.onChild,
     });
+    observedCodexThreadId = observedCodexThreadId
+        ?? (0, runtime_1.extractCodexThreadId)(`${result.stdout}\n${result.stderr}\n${result.outputTail}`);
+    if (!observedCodexThreadId) {
+        if (result.tokenUsage.usageParseError) {
+            console.warn('Codex thread id was not observed; rollout token usage could not be read.');
+        }
+        return result;
+    }
+    const rolloutUsage = await (0, runtime_1.readCodexRolloutTokenUsageForThread)(observedCodexThreadId);
+    if (rolloutUsage.usageParseError || rolloutUsage.totalTokens === null) {
+        if (result.tokenUsage.usageParseError) {
+            console.warn(`Codex rollout token usage could not be read for thread ${observedCodexThreadId}: ${rolloutUsage.usageParseError ?? 'unknown_error'}.`);
+        }
+        return result;
+    }
+    if (!result.tokenUsage.usageParseError
+        && result.tokenUsage.totalTokens !== null
+        && result.tokenUsage.totalTokens !== rolloutUsage.totalTokens) {
+        console.warn(`Codex stream token usage (${result.tokenUsage.totalTokens}) differed from rollout token usage (${rolloutUsage.totalTokens}); using rollout usage.`);
+    }
+    return {
+        ...result,
+        tokenUsage: rolloutUsage,
+        tokensUsed: rolloutUsage.totalTokens,
+    };
 }
 async function runClaude(input) {
     const denyReadRoots = resolveClaudeDenyReadRoots(input.workspaceDir);
@@ -1781,6 +2019,26 @@ function readPlaydropPluginVersion(pluginRoot) {
     }
     return null;
 }
+function readWorkerTargetUpdateFailure() {
+    const failureFile = node_process_1.default.env.PLAYDROP_WORKER_TARGET_UPDATE_FAILURE_FILE?.trim() ?? '';
+    if (!failureFile || !(0, node_fs_1.existsSync)(failureFile)) {
+        return null;
+    }
+    const parsed = JSON.parse((0, node_fs_1.readFileSync)(failureFile, 'utf8'));
+    const error = typeof parsed.error === 'string' ? parsed.error.trim() : '';
+    const writtenAt = typeof parsed.writtenAt === 'string' ? parsed.writtenAt.trim() : '';
+    if (!error || !writtenAt) {
+        throw new Error('worker_update_target_failure_marker_invalid');
+    }
+    return {
+        error,
+        writtenAt,
+        targetCliVersion: typeof parsed.targetCliVersion === 'string' ? parsed.targetCliVersion : null,
+        minimumCliVersion: typeof parsed.minimumCliVersion === 'string' ? parsed.minimumCliVersion : null,
+        targetPluginVersion: typeof parsed.targetPluginVersion === 'string' ? parsed.targetPluginVersion : null,
+        minimumPluginVersion: typeof parsed.minimumPluginVersion === 'string' ? parsed.minimumPluginVersion : null,
+    };
+}
 function collectWorkerLocalStatus() {
     const degradedReasons = [];
     let codexVersion = null;
@@ -1791,6 +2049,7 @@ function collectWorkerLocalStatus() {
     let pluginRoot = null;
     let pluginVersion = null;
     let pluginError = null;
+    let targetUpdateFailure = null;
     try {
         codexVersion = probeCodexInstallation()?.codexVersion ?? null;
     }
@@ -1829,6 +2088,12 @@ function collectWorkerLocalStatus() {
         pluginError = errorMessage(error);
         degradedReasons.push(errorCode(error));
     }
+    try {
+        targetUpdateFailure = readWorkerTargetUpdateFailure();
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
     let capabilities = null;
     try {
         capabilities = buildWorkerCapabilities({
@@ -1849,6 +2114,9 @@ function collectWorkerLocalStatus() {
                 agent.pluginVersion = pluginVersion;
             }
         }
+        if (targetUpdateFailure) {
+            capabilities.targetUpdateFailure = targetUpdateFailure;
+        }
         for (const reason of capabilities.degradedReasons ?? []) {
             degradedReasons.push(reason);
         }
@@ -2103,23 +2371,42 @@ set -eu
 export PLAYDROP_WORKER_WRAPPER_CONTRACT_VERSION="${WORKER_WRAPPER_CONTRACT_VERSION}"
 POLICY_FILE="${policyFile}"
 FAILURE_FILE="${failureFile}"
+export PLAYDROP_WORKER_TARGET_UPDATE_FAILURE_FILE="$FAILURE_FILE"
 BACKOFF_SECONDS="\${PLAYDROP_WORKER_UPDATE_FAILURE_BACKOFF_SECONDS:-30}"
+TARGET_CLI_VERSION=""
+MINIMUM_CLI_VERSION=""
+TARGET_PLUGIN_VERSION=""
+MINIMUM_PLUGIN_VERSION=""
+TARGET_UPDATE_FAILED=0
 
 record_failure() {
-  node - "$FAILURE_FILE" "$1" <<'NODE'
+  node - "$FAILURE_FILE" "$1" "$TARGET_CLI_VERSION" "$MINIMUM_CLI_VERSION" "$TARGET_PLUGIN_VERSION" "$MINIMUM_PLUGIN_VERSION" <<'NODE'
 const fs = require("fs");
 const path = require("path");
 const file = process.argv[2];
 const error = process.argv[3] || "worker_update_install_failed";
+const targetCliVersion = process.argv[4] || null;
+const minimumCliVersion = process.argv[5] || null;
+const targetPluginVersion = process.argv[6] || null;
+const minimumPluginVersion = process.argv[7] || null;
 fs.mkdirSync(path.dirname(file), { recursive: true });
 fs.writeFileSync(file, JSON.stringify({
   schemaVersion: 1,
   writtenAt: new Date().toISOString(),
   error,
+  targetCliVersion,
+  minimumCliVersion,
+  targetPluginVersion,
+  minimumPluginVersion,
 }, null, 2));
 NODE
 }
 
+record_target_failure() {
+  TARGET_UPDATE_FAILED=1
+  record_failure "worker_update_target_failed:$1"
+}
+
 fail_converge() {
   code="$1"
   reason="$2"
@@ -2156,24 +2443,69 @@ read_policy_value() {
   node -e 'const fs = require("fs"); const file = process.argv[1]; const key = process.argv[2]; if (!fs.existsSync(file)) process.exit(0); const policy = JSON.parse(fs.readFileSync(file, "utf8")); const value = policy && policy[key]; if (typeof value === "string") process.stdout.write(value);' "$POLICY_FILE" "$1"
 }
 
-validate_policy_file
-TARGET_CLI_VERSION="$(read_policy_value targetCliVersion)"
-TARGET_PLUGIN_VERSION="$(read_policy_value targetPluginVersion)"
+current_cli_version() {
+  playdrop --version 2>/dev/null | node -e 'const fs = require("fs"); const input = fs.readFileSync(0, "utf8"); const match = input.match(/\\d+\\.\\d+\\.\\d+(?:[-+][0-9A-Za-z.-]+)?/); if (!match) process.exit(1); process.stdout.write(match[0]);'
+}
 
-if [ -n "$TARGET_CLI_VERSION" ]; then
-  run_or_fail "worker_update_cli_install_failed" npm install -g --no-audit --no-fund "@playdrop/playdrop-cli@$TARGET_CLI_VERSION"
-fi
+version_meets() {
+  node - "$1" "$2" <<'NODE'
+const current = String(process.argv[2] || "").trim();
+const minimum = String(process.argv[3] || "").trim();
+if (!minimum) {
+  process.exit(0);
+}
+if (!current) {
+  process.exit(1);
+}
+function parse(version) {
+  const match = version.match(/^(\\d+)\\.(\\d+)\\.(\\d+)(?:[-+][0-9A-Za-z.-]+)?$/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+const parsedCurrent = parse(current);
+const parsedMinimum = parse(minimum);
+if (!parsedCurrent || !parsedMinimum) {
+  process.exit(current === minimum ? 0 : 1);
+}
+for (let index = 0; index < 3; index += 1) {
+  if (parsedCurrent[index] > parsedMinimum[index]) {
+    process.exit(0);
+  }
+  if (parsedCurrent[index] < parsedMinimum[index]) {
+    process.exit(1);
+  }
+}
+process.exit(0);
+NODE
+}
 
-if [ -n "$TARGET_PLUGIN_VERSION" ]; then
-  if command -v codex >/dev/null 2>&1; then
-    run_or_fail "worker_update_plugin_install_failed:codex" playdrop agents update-plugin codex
-  fi
-  if command -v claude >/dev/null 2>&1; then
-    run_or_fail "worker_update_plugin_install_failed:claude" playdrop agents update-plugin claude
-  fi
-  node - "$TARGET_PLUGIN_VERSION" <<'NODE' || fail_converge "$?" "worker_update_plugin_version_mismatch"
+check_plugin_versions() {
+  node - "$1" "$2" <<'NODE'
 const childProcess = require("child_process");
-const targetVersion = process.argv[2];
+const requiredVersion = String(process.argv[2] || "").trim();
+const mode = String(process.argv[3] || "").trim();
+if (!requiredVersion) {
+  process.exit(0);
+}
+function parse(version) {
+  const match = version.match(/^(\\d+)\\.(\\d+)\\.(\\d+)(?:[-+][0-9A-Za-z.-]+)?$/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+function meetsMinimum(current, minimum) {
+  const parsedCurrent = parse(current);
+  const parsedMinimum = parse(minimum);
+  if (!parsedCurrent || !parsedMinimum) {
+    return current === minimum;
+  }
+  for (let index = 0; index < 3; index += 1) {
+    if (parsedCurrent[index] > parsedMinimum[index]) {
+      return true;
+    }
+    if (parsedCurrent[index] < parsedMinimum[index]) {
+      return false;
+    }
+  }
+  return true;
+}
 const result = childProcess.spawnSync("playdrop", ["agents", "status", "--json"], { encoding: "utf8" });
 if (result.status !== 0) {
   process.exit(1);
@@ -2188,11 +2520,55 @@ const agents = Array.isArray(parsed && parsed.agents) ? parsed.agents : [];
 const checked = agents.filter((agent) => agent && agent.id !== "cursor" && agent.cli && agent.cli.installed);
 for (const agent of checked) {
   const version = agent && agent.plugin && typeof agent.plugin.version === "string" ? agent.plugin.version.trim() : "";
-  if (version !== targetVersion) {
+  if (mode === "target") {
+    if (version !== requiredVersion) {
+      process.exit(1);
+    }
+  } else if (!meetsMinimum(version, requiredVersion)) {
     process.exit(1);
   }
 }
 NODE
+}
+
+validate_policy_file
+TARGET_CLI_VERSION="$(read_policy_value targetCliVersion)"
+MINIMUM_CLI_VERSION="$(read_policy_value minimumCliVersion)"
+TARGET_PLUGIN_VERSION="$(read_policy_value targetPluginVersion)"
+MINIMUM_PLUGIN_VERSION="$(read_policy_value minimumPluginVersion)"
+
+if [ -n "$TARGET_CLI_VERSION" ]; then
+  if npm install -g --no-audit --no-fund "@playdrop/playdrop-cli@$TARGET_CLI_VERSION"; then
+    CURRENT_CLI_VERSION="$(current_cli_version)" || CURRENT_CLI_VERSION=""
+    if [ "$CURRENT_CLI_VERSION" != "$TARGET_CLI_VERSION" ]; then
+      record_target_failure "worker_update_cli_version_mismatch"
+    fi
+  else
+    record_target_failure "worker_update_cli_install_failed"
+  fi
+fi
+
+if [ -n "$TARGET_PLUGIN_VERSION" ]; then
+  if command -v codex >/dev/null 2>&1; then
+    playdrop agents update-plugin codex || record_target_failure "worker_update_plugin_install_failed:codex"
+  fi
+  if command -v claude >/dev/null 2>&1; then
+    playdrop agents update-plugin claude || record_target_failure "worker_update_plugin_install_failed:claude"
+  fi
+  check_plugin_versions "$TARGET_PLUGIN_VERSION" target || record_target_failure "worker_update_plugin_version_mismatch"
+fi
+
+if [ -n "$MINIMUM_CLI_VERSION" ]; then
+  CURRENT_CLI_VERSION="$(current_cli_version)" || fail_converge "$?" "worker_update_cli_below_minimum"
+  version_meets "$CURRENT_CLI_VERSION" "$MINIMUM_CLI_VERSION" || fail_converge "$?" "worker_update_cli_below_minimum"
+fi
+
+if [ -n "$MINIMUM_PLUGIN_VERSION" ]; then
+  check_plugin_versions "$MINIMUM_PLUGIN_VERSION" minimum || fail_converge "$?" "worker_update_plugin_below_minimum"
+fi
+
+if [ "$TARGET_UPDATE_FAILED" -eq 0 ]; then
+  rm -f "$FAILURE_FILE"
 fi
 
 node - "$POLICY_FILE" <<'NODE' || fail_converge "$?" "worker_update_agent_cli_install_failed"
@@ -2711,6 +3087,7 @@ async function startWorker(options = {}) {
             let eventDrainTimer = null;
             let eventDrainPromise = Promise.resolve();
             let fenced = false;
+            let heartbeatObservedFinalizedTask = false;
             let retainWorkspace = false;
             let workspaceDir = null;
             let availableSkillPaths = [];
@@ -2723,6 +3100,7 @@ async function startWorker(options = {}) {
             let agentCompletedAt = null;
             let agentResult = null;
             let telemetryReported = false;
+            let heartbeatTransientFailures = 0;
             const reportTelemetry = async (status, setupError) => {
                 if (!assignment) {
                     return;
@@ -2836,19 +3214,49 @@ async function startWorker(options = {}) {
                 heartbeatTimer = setInterval(() => {
                     client.workerHeartbeatAgentTask(task.id, { workerKey, leaseToken })
                         .then((heartbeat) => {
+                        heartbeatTransientFailures = 0;
                         if (heartbeat.action === 'abort') {
                             fenced = true;
                             activeTerminators.get(task.id)?.();
                         }
                     })
                         .catch((error) => {
-                        if (isWorkerAuthFailureError(error)) {
+                        const classification = classifyWorkerHeartbeatError(error);
+                        if (classification === 'session_expired') {
                             handleSessionExpiry();
                             return;
                         }
-                        if (isLeaseInvalidError(error)) {
-                            fenced = true;
-                            activeTerminators.get(task.id)?.();
+                        if (classification === 'lease_invalid') {
+                            void (async () => {
+                                const refreshed = await fetchTaskDetail(client, target, task.id).catch(() => null);
+                                if (refreshed?.task.status === 'DONE') {
+                                    fenced = true;
+                                    if (!heartbeatObservedFinalizedTask) {
+                                        heartbeatObservedFinalizedTask = true;
+                                        console.error(`Agent task ${task.id} lease ended after task completed as DONE; waiting for agent exit.`);
+                                    }
+                                    return;
+                                }
+                                if (refreshed && refreshed.task.status !== 'RUNNING' && refreshed.task.status !== 'QUEUED') {
+                                    console.error(`Agent task ${task.id} lease ended after task finalized as ${refreshed.task.status}; terminating agent child.`);
+                                }
+                                fenced = true;
+                                activeTerminators.get(task.id)?.();
+                            })().catch((heartbeatError) => {
+                                fenced = true;
+                                activeTerminators.get(task.id)?.();
+                                console.error(`Agent task lease check failed: ${heartbeatError instanceof Error ? heartbeatError.message : String(heartbeatError)}`);
+                            });
+                            return;
+                        }
+                        if (classification === 'transient_network') {
+                            heartbeatTransientFailures += 1;
+                            console.error(`Agent task heartbeat transient failure ${heartbeatTransientFailures}/${TASK_HEARTBEAT_TRANSIENT_FAILURE_LIMIT}: ${error instanceof Error ? error.message : String(error)}`);
+                            if (heartbeatTransientFailures >= TASK_HEARTBEAT_TRANSIENT_FAILURE_LIMIT) {
+                                fenced = true;
+                                activeTerminators.get(task.id)?.();
+                                console.error(`Agent task ${task.id} heartbeat could not reach the API; terminating agent child.`);
+                            }
                             return;
                         }
                         console.error(`Agent task heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -3277,9 +3685,11 @@ async function startWorker(options = {}) {
     }, { env: options.env });
 }
 async function reportTask(options) {
-    const message = options.message?.trim();
-    if (!message) {
-        (0, messages_1.printErrorWithHelp)('Task report requires a message.', ['Example: playdrop task report --phase build --pct 25 -m "Building first loop"'], { command: 'task report' });
+    const message = options.message?.trim() || null;
+    const done = options.done?.trim() || null;
+    const current = options.current?.trim() || null;
+    if (!message && !done && !current) {
+        (0, messages_1.printErrorWithHelp)('Task report requires a message, done, or current value.', ['Example: playdrop task report --phase build --done "Built the first loop" --current "Tuning controls"'], { command: 'task report' });
         node_process_1.default.exitCode = 1;
         return;
     }
@@ -3287,7 +3697,14 @@ async function reportTask(options) {
     const kind = normalizeTaskEventKind(options.kind);
     const phase = options.phase?.trim() || null;
     if (resolveWorkerEventQueueDir()) {
-        enqueueWorkerContextEvent({ kind, phase, message, pct });
+        enqueueWorkerContextEvent({
+            kind,
+            phase,
+            ...(message ? { message } : {}),
+            ...(done ? { done } : {}),
+            ...(current ? { current } : {}),
+            ...(pct !== null ? { pct } : {}),
+        });
         (0, output_1.printSuccess)('Task progress queued.');
         return;
     }
@@ -3384,6 +3801,34 @@ async function uploadTask(options = {}) {
     }
     (0, output_1.printSuccess)(`Uploaded ${published.creatorUsername}/${published.appName} version ${published.version}. Run "playdrop task done" to close the task.`);
 }
+async function claimSlugTask(options) {
+    const taskContext = readTaskContextFile();
+    if (taskContext.kind !== 'NEW_GAME' && taskContext.kind !== 'REMIX_GAME') {
+        throw new Error('task_claim_slug_not_allowed_for_kind');
+    }
+    const appName = normalizeTaskClaimSlugAppName(options.appName);
+    const displayName = normalizeTaskClaimSlugDisplayName(options.displayName);
+    const ctx = await resolveTaskCommandContext('task claim-slug', options.env, taskContext);
+    if (!ctx) {
+        return;
+    }
+    const response = await ctx.client.workerClaimAgentTaskSlug(taskContext.taskId, {
+        appName,
+        displayName,
+    });
+    const claimedAppName = typeof response.appName === 'string' && response.appName.trim()
+        ? response.appName.trim()
+        : '';
+    if (claimedAppName !== appName) {
+        throw new Error('task_claim_slug_response_mismatch');
+    }
+    const workspaceDir = resolveTaskWorkspaceDir();
+    await writeWorkerTaskContextFile(workspaceDir, {
+        ...taskContext,
+        outputAppName: claimedAppName,
+    });
+    (0, output_1.printSuccess)(`Claimed app slug "${claimedAppName}" for ${displayName}.`);
+}
 async function completeTask(options) {
     const taskContext = readTaskContextFile();
     if (taskContext.kind === 'GAME_REVIEW') {
@@ -3402,21 +3847,48 @@ async function completeTask(options) {
     if (uploadResult.taskId !== taskContext.taskId) {
         throw new Error('task_done_upload_result_task_mismatch');
     }
-    await ctx.client.workerCompleteAgentTask(taskContext.taskId, {
-        taskToken: taskContext.taskToken,
-        appId,
-        appVersionId,
-        result: {
-            appId: uploadResult.appId,
-            appVersionId: uploadResult.appVersionId,
-            version: uploadResult.version,
-            appName: uploadResult.appName,
-            versionNodeId: uploadResult.versionNodeId,
-            creatorUsername: uploadResult.creatorUsername,
-            completedBy: 'agent',
-        },
+    const nextSteps = await readTaskNextStepsFileForCommand({
+        filePath: options.nextSteps,
+        command: 'task done',
+        ctx,
+        taskContext,
     });
-    (0, output_1.printSuccess)('Task marked done.');
+    if (nextSteps === NEXT_STEPS_READ_FAILED) {
+        return;
+    }
+    try {
+        await ctx.client.workerCompleteAgentTask(taskContext.taskId, {
+            taskToken: taskContext.taskToken,
+            appId,
+            appVersionId,
+            result: {
+                appId: uploadResult.appId,
+                appVersionId: uploadResult.appVersionId,
+                version: uploadResult.version,
+                appName: uploadResult.appName,
+                versionNodeId: uploadResult.versionNodeId,
+                creatorUsername: uploadResult.creatorUsername,
+                completedBy: 'agent',
+            },
+            ...(nextSteps !== undefined ? { nextSteps } : {}),
+        });
+    }
+    catch (error) {
+        if (error instanceof types_1.ApiError && error.status === 409 && error.code === 'remix_relation_missing') {
+            await ctx.client.workerFailAgentTask(taskContext.taskId, {
+                taskToken: taskContext.taskToken,
+                error: 'remix_relation_missing',
+                result: {
+                    appId: uploadResult.appId,
+                    appVersionId: uploadResult.appVersionId,
+                    appName: uploadResult.appName,
+                    version: uploadResult.version,
+                },
+            });
+        }
+        throw error;
+    }
+    (0, output_1.printSuccess)('Task marked done. Send one short final status sentence now, then stop.');
 }
 function normalizeReviewSubmitState(value) {
     const normalized = typeof value === 'string' ? value.trim().toUpperCase() : '';
@@ -3545,15 +4017,25 @@ async function submitReviewTask(options) {
     if (!ctx) {
         throw new Error('task_submit_review_auth_required');
     }
+    const nextSteps = await readTaskNextStepsFileForCommand({
+        filePath: options.nextSteps,
+        command: 'task submit-review',
+        ctx,
+        taskContext,
+    });
+    if (nextSteps === NEXT_STEPS_READ_FAILED) {
+        return;
+    }
     await ctx.client.workerSubmitAgentTaskReview(taskContext.taskId, {
         taskToken: taskContext.taskToken,
         appVersionId: taskContext.reviewAppVersionId ?? 0,
         reviewState: state,
         reviewMessage,
         creatorFeedback,
+        ...(nextSteps !== undefined ? { nextSteps } : {}),
         evidenceFiles,
     });
-    (0, output_1.printSuccess)('Review submitted.');
+    (0, output_1.printSuccess)('Review submitted. Send one short final status sentence now, then stop.');
 }
 async function failTask(options) {
     const message = options.message?.trim();
@@ -3572,5 +4054,5 @@ async function failTask(options) {
         error: message,
         result: { failedBy: 'agent' },
     });
-    (0, output_1.printSuccess)('Task marked failed.');
+    (0, output_1.printSuccess)('Task marked failed. Send one short final status sentence now, then stop.');
 }