@playdrop/playdrop-cli 0.12.41 → 0.13.0

package/dist/commands/upload.js

@@ -8,17 +8,20 @@ exports.assertAgentNewGamePlaytestContract = assertAgentNewGamePlaytestContract;
 exports.assertTaskPlaytestEvidenceManifest = assertTaskPlaytestEvidenceManifest;
 exports.assertWorkerAppLocalUploadPreflight = assertWorkerAppLocalUploadPreflight;
 exports.publishWorkerAppProject = publishWorkerAppProject;
+exports.publishStaticHtmlProject = publishStaticHtmlProject;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const semver_1 = require("semver");
 const types_1 = require("@playdrop/types");
 const apps_1 = require("../apps");
+const staticHtml_1 = require("../apps/staticHtml");
 const registration_1 = require("../apps/registration");
 const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
 const catalogue_1 = require("../catalogue");
 const messages_1 = require("../messages");
+const output_1 = require("../output");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
@@ -1142,6 +1145,10 @@ function printResolvedUploadAccount(input) {
     console.log(`Resolved account: ${username} (${input.env})`);
 }
 async function upload(pathOrName, options) {
+    const directEntryPath = (0, node_path_1.resolve)(pathOrName);
+    const directStaticHtml = (0, node_fs_1.existsSync)(directEntryPath)
+        && (0, node_fs_1.statSync)(directEntryPath).isFile()
+        && (0, node_path_1.basename)(directEntryPath).toLowerCase() === 'index.html';
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     const workspaceRoot = resolveUploadWorkspaceRoot(pathOrName, selection.resolution);
     const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project publish', 'Publishing content', {
@@ -1152,10 +1159,12 @@ async function upload(pathOrName, options) {
         return;
     }
     const { client, env, envConfig } = ctx;
-    printResolvedUploadAccount({
-        env,
-        username: ctx.account?.username,
-    });
+    if (!options?.json) {
+        printResolvedUploadAccount({
+            env,
+            username: ctx.account?.username,
+        });
+    }
     let userInfo = { username: null, role: null, user: null };
     try {
         userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
@@ -1167,6 +1176,30 @@ async function upload(pathOrName, options) {
         throw error;
     }
     const owner = resolveUploadOwner(userInfo.username, ctx.workspaceAuth?.config.ownerUsername);
+    if (directStaticHtml) {
+        if (!userInfo.username || !userInfo.user) {
+            throw new Error('static_game_publish_authenticated_user_missing');
+        }
+        const result = await publishStaticHtmlProject({
+            client,
+            projectDir: (0, node_path_1.dirname)(directEntryPath),
+            creatorUsername: userInfo.username,
+            primarySurface: 'DESKTOP',
+            apiBase: envConfig.apiBase,
+            webBase: envConfig.webBase,
+            token: ctx.token,
+            user: userInfo.user,
+        });
+        if (options?.json) {
+            (0, output_1.printJson)(result);
+        }
+        else {
+            (0, output_1.printSuccess)(`Published private static game ${result.creatorUsername}/${result.appName}@${result.version}`);
+            console.log(result.playUrl);
+            result.warnings.forEach((warning) => console.warn(warning));
+        }
+        return;
+    }
     const tagGroupLoad = (0, catalogue_1.resolveCatalogueTagGroups)(workspaceRoot);
     if (tagGroupLoad.errors.length > 0) {
         (0, taskSelection_1.reportTaskErrors)(tagGroupLoad.errors.map((message) => ({
@@ -1234,9 +1267,16 @@ function assertAgentNewGamePlaytestContract(task) {
         throw new Error('agent_task_playtest_tapes_required: NEW_GAME catalogue.json must declare one playtest tape per supported surface.');
     }
     for (const surface of task.surfaceTargets) {
-        if (!task.playtestTapes[surface]) {
+        const tape = task.playtestTapes[surface];
+        if (!tape) {
             throw new Error(`agent_task_playtest_tape_missing:${surface}`);
         }
+        if (tape.startOnlyEventCount <= 0) {
+            throw new Error(`agent_task_playtest_start_only_required:${surface}: the tape must include an explicit startup action.`);
+        }
+        if (tape.events[0]?.atMs !== 0) {
+            throw new Error(`agent_task_playtest_ready_relative_timing_required:${surface}: the first startup event must run at 0 ms after sdk.host.ready().`);
+        }
     }
 }
 const WORKER_SUPERVISOR_SOURCE_EXCLUDES = [
@@ -1823,58 +1863,6 @@ function buildRequiredTaskPlaytestProof(task, manifest, currentSelfPlaytestCaptu
     }
     return parsed.value;
 }
-function assertRequiredCausalChecks(manifest) {
-    const rawChecks = manifest.causalChecks;
-    if (!rawChecks || typeof rawChecks !== 'object' || Array.isArray(rawChecks)) {
-        throw new Error(formatPlaytestEvidenceManifestError('causalChecks must contain matchedRuns, counterfactual, replay, challenge, and readability3D for NEW_GAME tasks.'));
-    }
-    const checks = rawChecks;
-    assertExactObjectKeys(checks, ['matchedRuns', 'counterfactual', 'replay', 'challenge', 'readability3D'], 'causalChecks');
-    const requirePassingCheck = (name, stringKeys, booleanKeys) => {
-        const rawCheck = checks[name];
-        if (!rawCheck || typeof rawCheck !== 'object' || Array.isArray(rawCheck)) {
-            throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.${name} must be an object.`));
-        }
-        const check = rawCheck;
-        assertExactObjectKeys(check, [...stringKeys, ...booleanKeys], `causalChecks.${name}`);
-        for (const key of stringKeys) {
-            if (typeof check[key] !== 'string' || !check[key].trim()) {
-                throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.${name}.${key} must be a non-empty string.`));
-            }
-        }
-        for (const key of booleanKeys) {
-            if (typeof check[key] !== 'boolean') {
-                throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.${name}.${key} must be boolean.`));
-            }
-        }
-        if (check.passed !== true) {
-            throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.${name}.passed must be true before upload.`));
-        }
-        return check;
-    };
-    if (!Array.isArray(checks.matchedRuns) || checks.matchedRuns.length === 0) {
-        throw new Error(formatPlaytestEvidenceManifestError('causalChecks.matchedRuns must include the primary-surface comparison.'));
-    }
-    for (const [index, rawRun] of checks.matchedRuns.entries()) {
-        if (!rawRun || typeof rawRun !== 'object' || Array.isArray(rawRun)) {
-            throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.matchedRuns[${index}] must be an object.`));
-        }
-        const run = rawRun;
-        assertExactObjectKeys(run, ['surface', 'zeroInputOutcome', 'startOnlyOutcome', 'fullTapeOutcome', 'criterion', 'passed'], `causalChecks.matchedRuns[${index}]`);
-        for (const key of ['surface', 'zeroInputOutcome', 'startOnlyOutcome', 'fullTapeOutcome', 'criterion']) {
-            if (typeof run[key] !== 'string' || !run[key].trim()) {
-                throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.matchedRuns[${index}].${key} must be a non-empty string.`));
-            }
-        }
-        if (run.passed !== true) {
-            throw new Error(formatPlaytestEvidenceManifestError(`causalChecks.matchedRuns[${index}].passed must be true before upload.`));
-        }
-    }
-    requirePassingCheck('counterfactual', ['normalInput', 'perturbedInput', 'normalOutcome', 'perturbedOutcome'], ['passed']);
-    requirePassingCheck('replay', ['action', 'outcome'], ['applicable', 'passed']);
-    requirePassingCheck('challenge', ['claim', 'action', 'outcome'], ['passed']);
-    requirePassingCheck('readability3D', ['controlledEntity', 'objectiveOrHazard', 'primaryActionEffect'], ['applicable', 'passed']);
-}
 function assertTaskPlaytestEvidenceManifest(task, options = {}) {
     const manifest = readPlaytestEvidenceManifest(task);
     if (manifest.version !== 1) {
@@ -1918,9 +1906,6 @@ function assertTaskPlaytestEvidenceManifest(task, options = {}) {
     if (!hasCurrentSelfPlaytest) {
         throw new Error(formatPlaytestEvidenceManifestError(`playtest-evidence.json must include a non-final self-playtest checkedAt after the last source change${sourceLastModifiedAt ? ` (${sourceLastModifiedAt})` : ''}.`));
     }
-    if (options.requireOutcomeProof) {
-        assertRequiredCausalChecks(manifest);
-    }
     return options.requireOutcomeProof
         ? buildRequiredTaskPlaytestProof(task, manifest, currentSelfPlaytestCaptures)
         : null;
@@ -2080,6 +2065,7 @@ async function publishWorkerAppProject(input) {
         agentTaskId: input.taskId,
         playtestProof: playtestProof ?? undefined,
         mediaCaptureRequired: input.executionTarget === 'FIRST_PARTY',
+        machineCausalGateRequired: input.kind === 'NEW_GAME',
         captureSession,
     });
     if (!uploadResult.versionCreated || !uploadResult.version) {
@@ -2101,3 +2087,88 @@ async function publishWorkerAppProject(input) {
         warnings: [...selection.warnings, ...warnings],
     };
 }
+async function publishStaticHtmlProject(input) {
+    const creatorUsername = input.creatorUsername.trim();
+    if (!creatorUsername) {
+        throw new Error('static_game_publish_creator_username_missing');
+    }
+    if (input.user.username !== creatorUsername && input.user.role !== 'ADMIN') {
+        throw new Error(`static_game_publish_on_behalf_requires_admin:${input.user.username}:${creatorUsername}`);
+    }
+    const prepared = await (0, staticHtml_1.prepareStaticHtmlProject)({
+        projectDir: input.projectDir,
+        taskId: input.taskId,
+        appName: input.claimedAppName?.trim() || undefined,
+        primarySurface: input.primarySurface,
+    });
+    try {
+        if (input.taskId !== undefined && !input.claimedAppName?.trim()) {
+            const taskToken = input.taskToken?.trim() ?? '';
+            if (!taskToken) {
+                throw new Error('static_game_publish_task_token_missing');
+            }
+            const claimed = await input.client.workerClaimAgentTaskSlug(input.taskId, {
+                appName: prepared.runtimeTask.name,
+                displayName: prepared.metadata.title,
+            });
+            if (claimed.appName !== prepared.runtimeTask.name) {
+                throw new Error(`static_game_publish_slug_claim_mismatch:${claimed.appName}:${prepared.runtimeTask.name}`);
+            }
+        }
+        const { app } = await (0, registration_1.ensureRegisteredHostedAppShell)({
+            client: input.client,
+            creatorUsername,
+            task: prepared.runtimeTask,
+            agentTaskId: input.taskId,
+        });
+        if (typeof app.id !== 'number' || !Number.isInteger(app.id) || app.id <= 0) {
+            throw new Error('static_game_publish_app_registration_failed');
+        }
+        const appId = app.id;
+        const captureSession = input.taskId !== undefined && input.taskToken?.trim()
+            ? { appId, taskId: input.taskId, taskToken: input.taskToken.trim() }
+            : null;
+        const { upload, warnings } = await (0, apps_1.runAppPipeline)(input.client, prepared.runtimeTask, {
+            creatorUsername,
+            apiBase: input.apiBase,
+            webBase: normalizePortalBase(input.webBase ?? undefined),
+            token: input.token,
+            user: input.user,
+            runLocalLoadCheck: true,
+            devRouterPort: input.devRouterPort,
+            runStagedUploadLoadCheck: true,
+            ensureRegisteredAppShell: true,
+            agentTaskId: input.taskId,
+            mediaCaptureRequired: false,
+            machineCausalGateRequired: false,
+            captureSession,
+            artifacts: prepared.artifacts,
+        });
+        if (!upload.version || !Number.isInteger(upload.versionId) || !upload.versionNodeId?.trim()) {
+            throw new Error('static_game_publish_version_result_missing');
+        }
+        return {
+            appId,
+            appVersionId: upload.versionId,
+            versionNodeId: upload.versionNodeId,
+            version: upload.version,
+            appName: prepared.runtimeTask.name,
+            creatorUsername,
+            sourceHash: prepared.sourceHash,
+            runtimeHash: prepared.runtimeHash,
+            sourceContainsInjectedSdk: false,
+            runtimeContainsInjectedSdk: true,
+            hostedLoadCheckPassed: true,
+            warnings: [...prepared.metadata.warnings, ...warnings],
+            playUrl: (0, appUrls_1.buildPlatformPrivateDraftPlayUrl)(input.webBase, {
+                creatorUsername,
+                appName: prepared.runtimeTask.name,
+                appType: 'GAME',
+                version: upload.version,
+            }),
+        };
+    }
+    finally {
+        await prepared.cleanup();
+    }
+}

package/dist/commands/worker/instrument-evidence.js

@@ -260,7 +260,7 @@ function readAndValidateInstrumentEvidenceManifest(input) {
         const rawCapture = parsed.captures?.[name];
         if (!rawCapture) {
             if (types_1.REQUIRED_INSTRUMENT_EVIDENCE_NAMES.includes(name)) {
-                throw new Error(`invalid_instrument_evidence_capture:${name}`);
+                throw new Error(`invalid_instrument_evidence_capture:${groupId}:${name}`);
             }
             continue;
         }

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

@@ -1,4 +1,6 @@
 export declare const DEFAULT_CODEX_TIMEOUT_MS: number;
+export declare const DEFAULT_CREATOR_AGENT_TIMEOUT_MS: number;
+export declare const DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS: number;
 export declare const DEFAULT_WORKER_TOKEN_CAP = 20000000;
 export declare const DEFAULT_CODEX_LOG_TAIL_CHARS = 12000;
 export declare const DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = 10000;
@@ -11,6 +13,7 @@ export type LoggedProcessResult = {
     timedOut: boolean;
     tokenUsage: AgentTokenUsage;
     tokensUsed: number | null;
+    providerSessionId?: string | null;
 };
 export type AgentTokenUsage = {
     inputTokens: number | null;
@@ -31,6 +34,7 @@ export declare function readEnvBoolean(name: string, fallback: boolean): boolean
 export declare function extractAgentTokenUsage(output: string): AgentTokenUsage;
 export declare function extractCodexRolloutTokenUsage(output: string): AgentTokenUsage;
 export declare function extractCodexThreadId(output: string): string | null;
+export declare function extractClaudeSessionId(output: string): string | null;
 export type CodexRolloutTokenUsageReadOptions = {
     sessionsRoot?: string;
     deleteAfterRead?: boolean;
@@ -63,6 +67,7 @@ export declare function buildCodexExecArgs(input: {
     networkAccess: boolean;
     sandboxMode?: CodexSandboxMode;
     imagePaths?: string[];
+    resumeSessionId?: string | null;
 }): string[];
 export type CodexSandboxMode = 'danger-full-access' | 'workspace-write' | 'read-only';
 export declare function readCodexSandboxMode(env?: NodeJS.ProcessEnv): CodexSandboxMode;
@@ -75,6 +80,8 @@ export declare function buildClaudeExecArgs(input: {
     workspaceDir?: string | null;
     denyReadRoots?: string[] | null;
     pluginDir?: string | null;
+    playdropCliEnabled?: boolean;
+    resumeSessionId?: string | null;
 }): string[];
 export declare const PLAYWRIGHT_MCP_VERSION = "0.0.78";
 export type WorkerInstrumentSurface = 'DESKTOP' | 'MOBILE_LANDSCAPE' | 'MOBILE_PORTRAIT';
@@ -86,6 +93,7 @@ export declare function buildPlaywrightMcpServerConfig(surface?: WorkerInstrumen
 export declare function buildClaudePermissionSettings(input?: {
     workspaceDir?: string | null;
     denyReadRoots?: string[];
+    playdropCliEnabled?: boolean;
 }): {
     permissions: {
         allow: string[];
@@ -108,3 +116,9 @@ export declare function buildWorkerChildEnv(input: {
     playwrightBrowsersPath?: string;
     baseEnv?: NodeJS.ProcessEnv;
 }): NodeJS.ProcessEnv;
+export declare function buildCleanRoomChildEnv(input: {
+    binDir: string;
+    homeDir?: string;
+    codexHomeDir?: string;
+    baseEnv?: NodeJS.ProcessEnv;
+}): NodeJS.ProcessEnv;

package/dist/commands/worker/runtime.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAYWRIGHT_MCP_VERSION = 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.PLAYWRIGHT_MCP_VERSION = exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = exports.DEFAULT_CODEX_LOG_TAIL_CHARS = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
 exports.resolveDescendantProcessIds = resolveDescendantProcessIds;
 exports.readPositiveEnvInt = readPositiveEnvInt;
 exports.readEnvBoolean = readEnvBoolean;
 exports.extractAgentTokenUsage = extractAgentTokenUsage;
 exports.extractCodexRolloutTokenUsage = extractCodexRolloutTokenUsage;
 exports.extractCodexThreadId = extractCodexThreadId;
+exports.extractClaudeSessionId = extractClaudeSessionId;
 exports.readCodexRolloutTokenUsageForThread = readCodexRolloutTokenUsageForThread;
 exports.extractCodexTokensUsed = extractCodexTokensUsed;
 exports.assertWorkerTokenUsageWithinCap = assertWorkerTokenUsageWithinCap;
@@ -22,13 +23,17 @@ exports.buildPlaywrightMcpServerConfig = buildPlaywrightMcpServerConfig;
 exports.buildClaudePermissionSettings = buildClaudePermissionSettings;
 exports.buildClaudeDeniedPermissionRules = buildClaudeDeniedPermissionRules;
 exports.buildWorkerChildEnv = buildWorkerChildEnv;
+exports.buildCleanRoomChildEnv = buildCleanRoomChildEnv;
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const surfaceProfiles_1 = require("../../apps/surfaceProfiles");
 const CHILD_KILL_GRACE_MS = 10000;
 exports.DEFAULT_CODEX_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+exports.DEFAULT_CREATOR_AGENT_TIMEOUT_MS = 60 * 60 * 1000;
+exports.DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS = 30 * 60 * 1000;
 exports.DEFAULT_WORKER_TOKEN_CAP = 20000000;
 exports.DEFAULT_CODEX_LOG_TAIL_CHARS = 12000;
 exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = 10000;
@@ -296,6 +301,25 @@ function extractCodexThreadId(output) {
     }
     return null;
 }
+function extractClaudeSessionId(output) {
+    for (const line of output.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+            continue;
+        }
+        try {
+            const root = coerceRecord(JSON.parse(trimmed));
+            const rawSessionId = root?.session_id ?? root?.sessionId;
+            if (typeof rawSessionId === 'string' && rawSessionId.trim()) {
+                return rawSessionId.trim();
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
 async function findCodexRolloutFileForThread(threadId, sessionsRoot) {
     const stack = [{ dir: sessionsRoot, depth: 0 }];
     const matches = [];
@@ -531,10 +555,24 @@ async function runLoggedProcess(input) {
 }
 function buildCodexExecArgs(input) {
     const sandboxMode = input.sandboxMode ?? 'danger-full-access';
+    const resumeSessionId = input.resumeSessionId?.trim() ?? '';
+    if (resumeSessionId) {
+        return [
+            'exec',
+            'resume',
+            '--json',
+            '--skip-git-repo-check',
+            '--model',
+            input.model,
+            '-c',
+            `model_reasoning_effort="${input.reasoningEffort}"`,
+            resumeSessionId,
+            '-',
+        ];
+    }
     const args = [
         'exec',
         '--json',
-        '--ephemeral',
         '--sandbox',
         sandboxMode,
         '--cd',
@@ -581,6 +619,7 @@ function buildClaudeExecArgs(input) {
     const permissionSettings = buildClaudePermissionSettings({
         workspaceDir: input.workspaceDir,
         denyReadRoots: input.denyReadRoots ?? [],
+        playdropCliEnabled: input.playdropCliEnabled,
     });
     const permissionMode = input.chrome || input.playwrightMcp ? 'bypassPermissions' : 'acceptEdits';
     // MCP tools are deferred behind ToolSearch in the Claude CLI; without it in the toolset a
@@ -590,7 +629,7 @@ function buildClaudeExecArgs(input) {
         : input.playwrightMcp
             ? [...CLAUDE_BASE_TOOL_NAMES, 'ToolSearch'].join(',')
             : CLAUDE_BASE_TOOL_NAMES.join(',');
-    const allowedPermissionRules = buildClaudeAllowedPermissionRules(input.workspaceDir);
+    const allowedPermissionRules = buildClaudeAllowedPermissionRules(input.workspaceDir, input.playdropCliEnabled);
     const allowedTools = input.chrome
         ? [...allowedPermissionRules, ...CLAUDE_CHROME_TOOL_NAMES]
         : input.playwrightMcp
@@ -609,7 +648,6 @@ function buildClaudeExecArgs(input) {
         'stream-json',
         '--verbose',
         '--include-partial-messages',
-        '--no-session-persistence',
         '--permission-mode',
         permissionMode,
         '--tools',
@@ -635,6 +673,10 @@ function buildClaudeExecArgs(input) {
     if (effort) {
         args.push('--effort', effort);
     }
+    const resumeSessionId = input.resumeSessionId?.trim() ?? '';
+    if (resumeSessionId) {
+        args.push('--resume', resumeSessionId);
+    }
     return args;
 }
 const CLAUDE_BASE_TOOL_NAMES = [
@@ -702,6 +744,7 @@ const CLAUDE_BUILD_PERMISSION_RULES = [
     'Grep',
     'Bash(playdrop *)',
     'Bash(./bin/playdrop *)',
+    'Bash(../bin/playdrop *)',
     'Bash(bin/playdrop *)',
     'Bash(node *)',
     'Bash(npm *)',
@@ -709,6 +752,7 @@ const CLAUDE_BUILD_PERMISSION_RULES = [
     'Bash(cp *)',
     'Bash(mv *)',
     'Bash(file *)',
+    'Bash(curl *)',
     'Bash(sips *)',
     'Bash(ls *)',
     'Bash(pwd)',
@@ -731,7 +775,7 @@ function normalizeClaudePermissionPath(value) {
     }
     return node_path_1.default.resolve(trimmed).replace(/\\/g, '/').replace(/\/+$/, '');
 }
-function buildClaudeAllowedPermissionRules(workspaceDir) {
+function buildClaudeAllowedPermissionRules(workspaceDir, playdropCliEnabled = true) {
     const workspaceRoot = typeof workspaceDir === 'string' && workspaceDir.trim()
         ? normalizeClaudePermissionPath(workspaceDir)
         : null;
@@ -743,14 +787,14 @@ function buildClaudeAllowedPermissionRules(workspaceDir) {
         `Read(${absoluteWorkspacePattern})`,
         `Edit(${absoluteWorkspacePattern})`,
         `Write(${absoluteWorkspacePattern})`,
-        `Bash(${workspaceRoot}/bin/playdrop *)`,
-        ...CLAUDE_BUILD_PERMISSION_RULES,
+        ...(playdropCliEnabled ? [`Bash(${workspaceRoot}/bin/playdrop *)`] : []),
+        ...CLAUDE_BUILD_PERMISSION_RULES.filter((rule) => (playdropCliEnabled || !rule.toLowerCase().includes('playdrop'))),
     ];
 }
 function buildClaudePermissionSettings(input = {}) {
     return {
         permissions: {
-            allow: buildClaudeAllowedPermissionRules(input.workspaceDir),
+            allow: buildClaudeAllowedPermissionRules(input.workspaceDir, input.playdropCliEnabled),
             deny: buildClaudeDeniedPermissionRules(input.denyReadRoots ?? []),
         },
     };
@@ -860,3 +904,48 @@ function buildWorkerChildEnv(input) {
     }
     return child;
 }
+function buildCleanRoomChildEnv(input) {
+    const base = input.baseEnv ?? process.env;
+    const child = {};
+    for (const key of [
+        'HOME',
+        'USER',
+        'SHELL',
+        'TMPDIR',
+        'LANG',
+        'TERM',
+        'ANTHROPIC_API_KEY',
+        'OPENAI_API_KEY',
+        'HTTP_PROXY',
+        'HTTPS_PROXY',
+        'ALL_PROXY',
+        'NO_PROXY',
+    ]) {
+        const value = base[key];
+        if (typeof value === 'string')
+            child[key] = value;
+    }
+    for (const [key, value] of Object.entries(base)) {
+        if (key.startsWith('LC_') && typeof value === 'string')
+            child[key] = value;
+    }
+    if (input.homeDir !== undefined) {
+        const homeDir = input.homeDir.trim();
+        if (!homeDir || !node_path_1.default.isAbsolute(homeDir))
+            throw new Error('invalid_worker_child_home_dir');
+        child.HOME = homeDir;
+    }
+    if (input.codexHomeDir !== undefined) {
+        const codexHomeDir = input.codexHomeDir.trim();
+        if (!codexHomeDir || !node_path_1.default.isAbsolute(codexHomeDir))
+            throw new Error('invalid_worker_child_codex_home_dir');
+        child.CODEX_HOME = codexHomeDir;
+    }
+    const safeHostPath = (base.PATH ?? '').split(node_path_1.default.delimiter).filter((directory) => {
+        if (!directory || !node_path_1.default.isAbsolute(directory))
+            return false;
+        return !(0, node_fs_1.existsSync)(node_path_1.default.join(directory, process.platform === 'win32' ? 'playdrop.exe' : 'playdrop'));
+    });
+    child.PATH = [input.binDir, ...safeHostPath].join(node_path_1.default.delimiter);
+    return child;
+}

package/dist/commands/worker.d.ts

@@ -4,8 +4,14 @@ import { loadConfig } from '../config';
 import { runShell } from '../shellProbe';
 import { type WorkerPlaydropAssetRequirement } from './upload';
 import { type WorkerInstrumentSurface, type LoggedProcessResult, type LoggedProcessTranscriptChunk } from './worker/runtime';
-export { assertWorkerTokenUsageWithinCap, buildClaudeExecArgs, buildClaudePermissionSettings, buildCodexExecArgs, buildPlaywrightMcpCommand, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractCodexThreadId, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readCodexSandboxMode, readEnvBoolean, runLoggedProcess } from './worker/runtime';
+export { assertWorkerTokenUsageWithinCap, buildClaudeExecArgs, buildClaudePermissionSettings, buildCleanRoomChildEnv, buildCodexExecArgs, buildPlaywrightMcpCommand, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_CREATOR_AGENT_TIMEOUT_MS, DEFAULT_CREATOR_UPLOAD_RECOVERY_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractClaudeSessionId, extractCodexThreadId, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readCodexSandboxMode, readEnvBoolean, runLoggedProcess } from './worker/runtime';
 export type { AgentTokenUsage, LoggedProcessResult, LoggedProcessTranscriptChunk } from './worker/runtime';
+export declare function usesCreatorRecovery(kind: AgentTaskKind): boolean;
+export declare function buildCreatorRecoveryPrompt(input: {
+    prompt: string;
+    kind: AgentTaskKind;
+}): string;
+export declare function buildGameEvalRetryPrompt(prompt: string): string;
 export declare const WORKER_SESSION_EXPIRED_MESSAGE = "worker session expired: run \"playdrop auth login\" and start the worker again";
 export declare const 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/check/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
 type WorkerStartOptions = {
@@ -76,6 +82,7 @@ type TaskCatalogueReportOptions = {
 type TaskCompleteOptions = {
     env?: string;
     nextSteps?: string;
+    platformFeedbackFile?: string;
     summary?: string;
 };
 type TaskClaimSlugOptions = {
@@ -89,6 +96,7 @@ type TaskUploadOptions = {
 type TaskFailOptions = {
     env?: string;
     message?: string;
+    platformFeedbackFile?: string;
 };
 type TaskEvidenceOptions = {
     evidenceDir?: string;
@@ -105,6 +113,7 @@ type TaskSubmitReviewOptions = {
     state?: string;
     messageFile?: string;
     creatorFeedbackFile?: string;
+    platformFeedbackFile?: string;
     evidenceDir?: string;
     nextSteps?: string;
 };
@@ -166,6 +175,12 @@ export declare function claimBackoffDelayMs(currentMs: number, random?: () => nu
 export declare function resolveWorkerHomeDir(): string;
 export declare const WORKER_TASK_WORKSPACE_RETENTION = 20;
 export declare function pruneWorkerTaskWorkspaces(incomingWorkspaceDir: string, retention?: number): Promise<string[]>;
+export declare function prepareClaimedTaskWorkspace(input: {
+    workspaceDir: string;
+    attempt: number;
+}): Promise<{
+    resumed: boolean;
+}>;
 export declare function resolveWorkerInstrumentSurface(taskContext: Pick<WorkerTaskContextFile, 'kind' | 'metadata'>): WorkerInstrumentSurface | null;
 export declare function hasAgentTaskUploadedArtifact(task: Pick<AgentTaskResponse, 'appId' | 'appVersionId'>): boolean;
 export declare function appendWorkerTranscriptChunks(input: {
@@ -193,11 +208,17 @@ export declare function assertTaskUploadResultMatchesContext(input: {
 }): void;
 export declare function stageAssignmentWorkspaceV2(workspaceDir: string, workspace: WorkerTaskAssignmentV2['workspace']): Promise<void>;
 export declare function assertAssignmentPluginBundleExtractionBounds(buffer: Buffer): void;
+export declare function stageDevPluginWorkingTree(input: {
+    workingTree: string;
+    workspaceDir: string;
+    taskKind?: AgentTaskKind;
+}): Promise<string>;
 export declare function stageAssignmentPluginBundle(input: {
     workspaceDir: string;
+    extractionDir?: string;
     pluginBundle: WorkerTaskPluginV2;
     taskKind?: AgentTaskKind;
-}): Promise<string>;
+}): Promise<string | null>;
 export declare function resolveDevPluginWorkingTree(input: {
     workingTree?: string;
     env: string;
@@ -251,6 +272,8 @@ export declare function prepareCodexRunHomes(input: {
     envName: string;
     sourceCodexHome?: string;
     playdropConfig?: ReturnType<typeof loadConfig>;
+    stagePlaydropSession?: boolean;
+    preserveExisting?: boolean;
 }): Promise<{
     homeDir: string;
     codexHomeDir: string;
@@ -265,6 +288,7 @@ export declare function prepareClaudeRunConfig(input: {
 }>;
 export declare function removeAgentRunCredentials(workspaceDir: string): Promise<void>;
 export declare function removeStaleAgentRunCredentials(workerHomeDir?: string): Promise<void>;
+export declare function mergeCreatorRecoveryResults(runtime: AgentRuntime, initial: LoggedProcessResult, recovery: LoggedProcessResult): LoggedProcessResult;
 export declare function buildAgentFailureCode(agent: AgentRuntime, result: LoggedProcessResult, request?: {
     model: string;
     reasoningEffort?: string | null;
@@ -368,6 +392,7 @@ export declare function enforceInstrumentBrowserHygiene(assignment: WorkerTaskAs
     remainingTaskTabs: number;
     blankWindows: number;
 }>;
+export declare function assignmentRequiresRegisteredBundle(assignment: WorkerTaskAssignmentV2): boolean;
 export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
 export declare function reportTask(options: TaskReportOptions): Promise<void>;
 export declare function showTaskContext(): void;