@playdrop/playdrop-cli 0.12.6 → 0.12.8

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.12.4",
-  "build": 4,
+  "version": "0.12.6",
+  "build": 1,
   "runtimeSdkVersion": "0.12.5",
   "runtimeSdkBuild": 2,
   "clients": {

package/dist/apps/upload.js

@@ -100,13 +100,6 @@ function readMediaCaptureProof(input) {
     if (!binding || typeof binding !== 'object' || Array.isArray(binding)) {
         throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} is missing binding.`);
     }
-    const contentHash = typeof binding.contentHash === 'string' ? binding.contentHash.trim().toLowerCase() : '';
-    if (!isSha256Hex(contentHash)) {
-        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.contentHash must be a SHA-256 hex string.`);
-    }
-    if (contentHash !== input.artifacts.bundleHash) {
-        throw new Error(`agent_task_media_capture_build_mismatch: capture report contentHash does not match the bundle being uploaded for ${input.task.name}. Rerun "playdrop project capture" after the final build changes.`);
-    }
     const rawArtifactHashes = binding.artifactHashes;
     if (!rawArtifactHashes || typeof rawArtifactHashes !== 'object' || Array.isArray(rawArtifactHashes)) {
         throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.artifactHashes must be an object.`);
@@ -160,7 +153,6 @@ function readMediaCaptureProof(input) {
         throw new Error(`agent_task_media_capture_surface_missing: listing.captureReport did not capture ${missingSurfaces.join(', ')} for ${input.task.name}.`);
     }
     return {
-        contentHash,
         artifactHashes,
         capturedSurfaces,
     };
@@ -433,12 +425,8 @@ async function uploadAppVersion(client, task, artifacts, options) {
             if (options?.mediaCaptureRequired === true
                 && task.hostingMode !== 'EXTERNAL'
                 && !task.externalUrl) {
-                if (!artifacts) {
-                    throw new Error(`agent_task_media_capture_build_missing: ${task.name} has no hosted build artifacts to bind capture media to.`);
-                }
                 const mediaCaptureProof = readMediaCaptureProof({
                     task,
-                    artifacts,
                     preparedSessionFiles,
                 });
                 await client.recordAppUploadMediaCapture(creatorUsername, task.name, sessionId, mediaCaptureProof);

package/dist/commands/captureListing.d.ts

@@ -11,7 +11,6 @@ type CaptureListingOptions = {
     audio?: boolean;
     outputDir?: string;
     keepRaw?: boolean;
-    contentHash?: string;
 };
 type ParsedCaptureListingOptions = {
     targetArg?: string;
@@ -24,7 +23,6 @@ type ParsedCaptureListingOptions = {
     audio: boolean;
     outputDir: string | null;
     keepRaw: boolean;
-    contentHash: string | null;
     explicitDimensions: boolean;
 };
 type CaptureRect = {

package/dist/commands/captureListing.js

@@ -77,7 +77,6 @@ const MAX_FPS = 120;
 const MIN_SUPPORTED_MACOS_MAJOR = 26;
 const MIN_SUPPORTED_MACOS_MINOR = 4;
 const LISTING_CAPTURE_HOOK_TIMEOUT_MS = 60000;
-const SHA256_HEX_REGEX = /^[a-f0-9]{64}$/i;
 const LISTING_CAPTURE_MOBILE_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1';
 const SURFACE_CAPTURE_DIMENSIONS = {
     DESKTOP: { width: 1280, height: 720 },
@@ -157,12 +156,6 @@ function parseCaptureListingOptions(targetArg, options = {}) {
         maximum: durationSeconds,
     });
     const outputDir = options.outputDir?.trim() ? (0, node_path_1.resolve)(process.cwd(), options.outputDir.trim()) : null;
-    const contentHash = typeof options.contentHash === 'string' && options.contentHash.trim().length > 0
-        ? options.contentHash.trim().toLowerCase()
-        : null;
-    if (contentHash && !SHA256_HEX_REGEX.test(contentHash)) {
-        throw new Error('content_hash_invalid');
-    }
     return {
         targetArg,
         appName: options.app?.trim() || undefined,
@@ -174,7 +167,6 @@ function parseCaptureListingOptions(targetArg, options = {}) {
         audio: Boolean(options.audio),
         outputDir,
         keepRaw: Boolean(options.keepRaw),
-        contentHash,
         explicitDimensions,
     };
 }
@@ -640,12 +632,6 @@ function formatCommandError(error) {
             suggestions: [],
         };
     }
-    if (error.message === 'content_hash_invalid') {
-        return {
-            message: 'The --content-hash value must be a 64-character SHA-256 hex string.',
-            suggestions: [],
-        };
-    }
     if (error.message === 'listing_preview_support_missing') {
         return {
             message: 'This game does not declare preview support, so listing capture cannot run.',
@@ -1095,7 +1081,6 @@ async function captureListing(targetArg, options = {}) {
                 captures,
                 warnings: allWarnings,
                 binding: {
-                    contentHash: parsedOptions.contentHash,
                     artifactHashes,
                     capturedSurfaces,
                 },

package/dist/commands/login.d.ts

@@ -1,4 +1,3 @@
-import type { Readable } from 'stream';
 import { resetOpenBrowserForTests, setOpenBrowserForTests } from '../browser';
 export { resetOpenBrowserForTests, setOpenBrowserForTests, };
 type LoginOptions = {
@@ -6,17 +5,6 @@ type LoginOptions = {
     password?: string;
     key?: string;
     handoffToken?: string;
-    handoffTokenStdin?: boolean;
     json?: boolean;
 };
-type LoginRuntime = {
-    stdin?: Readable;
-};
-export declare const HANDOFF_TOKEN_STDIN_MAX_BYTES: number;
-type HandoffTokenStdinErrorCode = 'empty' | 'too_large' | 'read_failed';
-export declare class HandoffTokenStdinError extends Error {
-    readonly code: HandoffTokenStdinErrorCode;
-    constructor(code: HandoffTokenStdinErrorCode);
-}
-export declare function readHandoffTokenFromStdin(input?: Readable): Promise<string>;
-export declare function login(env: string, options?: LoginOptions, runtime?: LoginRuntime): Promise<void>;
+export declare function login(env: string, options?: LoginOptions): Promise<void>;

package/dist/commands/login.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HandoffTokenStdinError = exports.HANDOFF_TOKEN_STDIN_MAX_BYTES = exports.setOpenBrowserForTests = exports.resetOpenBrowserForTests = void 0;
-exports.readHandoffTokenFromStdin = readHandoffTokenFromStdin;
+exports.setOpenBrowserForTests = exports.resetOpenBrowserForTests = void 0;
 exports.login = login;
 const types_1 = require("@playdrop/types");
 const config_1 = require("../config");
@@ -13,40 +12,6 @@ Object.defineProperty(exports, "resetOpenBrowserForTests", { enumerable: true, g
 Object.defineProperty(exports, "setOpenBrowserForTests", { enumerable: true, get: function () { return browser_1.setOpenBrowserForTests; } });
 const output_1 = require("../output");
 const messages_1 = require("../messages");
-exports.HANDOFF_TOKEN_STDIN_MAX_BYTES = 8 * 1024;
-class HandoffTokenStdinError extends Error {
-    constructor(code) {
-        super(`handoff_token_stdin_${code}`);
-        this.name = 'HandoffTokenStdinError';
-        this.code = code;
-    }
-}
-exports.HandoffTokenStdinError = HandoffTokenStdinError;
-async function readHandoffTokenFromStdin(input = process.stdin) {
-    const chunks = [];
-    let byteCount = 0;
-    try {
-        for await (const chunk of input) {
-            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-            byteCount += buffer.byteLength;
-            if (byteCount > exports.HANDOFF_TOKEN_STDIN_MAX_BYTES) {
-                throw new HandoffTokenStdinError('too_large');
-            }
-            chunks.push(buffer);
-        }
-    }
-    catch (error) {
-        if (error instanceof HandoffTokenStdinError) {
-            throw error;
-        }
-        throw new HandoffTokenStdinError('read_failed');
-    }
-    const token = Buffer.concat(chunks, byteCount).toString('utf8').trim();
-    if (!token) {
-        throw new HandoffTokenStdinError('empty');
-    }
-    return token;
-}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -228,7 +193,7 @@ async function loginInBrowser(env, baseUrl, options = {}) {
     ], { command: 'login' });
     process.exitCode = 1;
 }
-async function login(env, options = {}, runtime = {}) {
+async function login(env, options = {}) {
     const envConfig = (0, environment_1.resolveEnvironmentConfig)(env);
     if (!envConfig) {
         const choices = (0, environment_1.formatEnvironmentList)();
@@ -245,13 +210,11 @@ async function login(env, options = {}, runtime = {}) {
     const argvHandoffToken = options.handoffToken?.trim();
     const hasApiKeyArgument = options.key !== undefined;
     const hasHandoffTokenArgument = options.handoffToken !== undefined;
-    const readsHandoffTokenFromStdin = options.handoffTokenStdin === true;
     const hasDirectCredentials = Boolean(username || password);
     const explicitLoginMethods = [
         hasApiKeyArgument ? 'key' : null,
         hasDirectCredentials ? 'credentials' : null,
         hasHandoffTokenArgument ? 'handoff' : null,
-        readsHandoffTokenFromStdin ? 'handoff-stdin' : null,
     ].filter(Boolean);
     if (explicitLoginMethods.length > 1) {
         (0, messages_1.printErrorWithHelp)('Choose exactly one login method.', [
@@ -259,7 +222,6 @@ async function login(env, options = {}, runtime = {}) {
             'Use "--username" with "--password" for direct login.',
             'Use "--key" by itself for API key login.',
             'Use "--handoff-token" by itself for native app handoff login.',
-            'Use "--handoff-token-stdin" by itself to read a native app handoff token from stdin.',
         ], { command: 'login' });
         process.exitCode = 1;
         return;
@@ -282,30 +244,13 @@ async function login(env, options = {}, runtime = {}) {
         process.exitCode = 1;
         return;
     }
-    let handoffToken = argvHandoffToken;
-    if (readsHandoffTokenFromStdin) {
-        try {
-            handoffToken = await readHandoffTokenFromStdin(runtime.stdin ?? process.stdin);
-        }
-        catch (error) {
-            const inputError = error instanceof HandoffTokenStdinError ? error : null;
-            const message = inputError?.code === 'too_large'
-                ? `Native app handoff input exceeded the ${exports.HANDOFF_TOKEN_STDIN_MAX_BYTES}-byte limit.`
-                : inputError?.code === 'empty'
-                    ? 'Native app handoff input was empty.'
-                    : 'Could not read native app handoff input from stdin.';
-            (0, messages_1.printErrorWithHelp)(message, ['Request a fresh handoff token from the PlayDrop app and retry.'], { command: 'login' });
-            process.exitCode = 1;
-            return;
-        }
-    }
     try {
         if (apiKey) {
             await loginWithKey(env, envConfig.apiBase, apiKey, { json: options.json });
             return;
         }
-        if (handoffToken) {
-            await loginWithHandoff(env, envConfig.apiBase, handoffToken, { json: options.json });
+        if (argvHandoffToken) {
+            await loginWithHandoff(env, envConfig.apiBase, argvHandoffToken, { json: options.json });
             return;
         }
         if (username && password) {

package/dist/commands/upgrade.d.ts

@@ -4,7 +4,6 @@ type UpgradeOptions = {
     worker?: boolean;
     env?: string;
     workerKey?: string;
-    updatePlugins?: boolean;
 };
 export declare function upgrade(options?: UpgradeOptions): Promise<void>;
 export {};

package/dist/commands/upgrade.js

@@ -49,7 +49,6 @@ function formatWorkerUpdateState(worker) {
         `update=${worker.updateState ?? 'unknown'}`,
         `ready=${worker.ready === true ? 'true' : worker.ready === false ? 'false' : 'unknown'}`,
         `cli=${worker.cliVersion ?? 'unknown'}`,
-        `plugin=${worker.pluginVersion ?? 'unknown'}`,
     ].join(' ');
 }
 async function observeManagedWorkerUpdate(input) {
@@ -69,7 +68,7 @@ async function observeManagedWorkerUpdate(input) {
             lastState = state;
         }
         if (worker.updateState === 'UPDATE_BLOCKED' || worker.lifecycleState === 'DEGRADED' || worker.ready === false) {
-            throw new Error(`playdrop_update_worker_failed: ${state}. Next action: run "playdrop worker status --json" on the worker host and inspect the wrapper failure marker under ~/.playdrop/worker.`);
+            throw new Error(`playdrop_update_worker_failed: ${state}. Next action: run "playdrop worker status --json" on the worker host and inspect the wrapper failure marker under the configured worker state directory.`);
         }
         if (worker.activeUpdateIntentId !== input.intentId
             && worker.lifecycleState === 'READY'

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

@@ -72,7 +72,10 @@ export declare function buildClaudeExecArgs(input: {
     denyReadRoots?: string[] | null;
     pluginDir?: string | null;
 }): string[];
-export declare function buildClaudePermissionSettings(denyReadRoots?: string[]): {
+export declare function buildClaudePermissionSettings(input?: {
+    workspaceDir?: string | null;
+    denyReadRoots?: string[];
+}): {
     permissions: {
         allow: string[];
         deny: string[];
@@ -86,5 +89,9 @@ export declare function buildWorkerChildEnv(input: {
     envName: string;
     eventDir?: string;
     devPort?: number;
+    homeDir?: string;
+    codexHomeDir?: string;
+    claudeConfigDir?: string;
+    playwrightBrowsersPath?: string;
     baseEnv?: NodeJS.ProcessEnv;
 }): NodeJS.ProcessEnv;

package/dist/commands/worker/runtime.js

@@ -440,6 +440,9 @@ function buildCodexExecArgs(input) {
     const args = [
         'exec',
         '--json',
+        '--ephemeral',
+        '--ignore-user-config',
+        '--ignore-rules',
         '--sandbox',
         sandboxMode,
         '--cd',
@@ -471,16 +474,22 @@ function buildClaudeExecArgs(input) {
     if (!model) {
         throw new Error('agent_task_assignment_model_missing');
     }
-    const permissionSettings = buildClaudePermissionSettings(input.denyReadRoots ?? []);
+    const permissionSettings = buildClaudePermissionSettings({
+        workspaceDir: input.workspaceDir,
+        denyReadRoots: input.denyReadRoots ?? [],
+    });
     const permissionMode = input.chrome ? 'bypassPermissions' : 'acceptEdits';
     const tools = input.chrome
         ? [...CLAUDE_BASE_TOOL_NAMES, ...CLAUDE_CHROME_TOOL_NAMES].join(',')
         : CLAUDE_BASE_TOOL_NAMES.join(',');
+    const allowedPermissionRules = buildClaudeAllowedPermissionRules(input.workspaceDir);
     const allowedTools = input.chrome
-        ? [...CLAUDE_ALLOWED_PERMISSION_RULES, ...CLAUDE_CHROME_TOOL_NAMES]
-        : CLAUDE_ALLOWED_PERMISSION_RULES;
+        ? [...allowedPermissionRules, ...CLAUDE_CHROME_TOOL_NAMES]
+        : allowedPermissionRules;
     const args = [
         '-p',
+        '--safe-mode',
+        '--strict-mcp-config',
         '--model',
         model,
         '--output-format',
@@ -543,17 +552,12 @@ const CLAUDE_CHROME_TOOL_NAMES = [
     'mcp__claude-in-chrome__tabs_create_mcp',
     'mcp__claude-in-chrome__upload_image',
 ];
-const CLAUDE_ALLOWED_PERMISSION_RULES = [
-    'Read',
-    'Edit',
-    'Write',
+const CLAUDE_BUILD_PERMISSION_RULES = [
     'Glob',
     'Grep',
-    'Bash',
     'Bash(playdrop *)',
     'Bash(./bin/playdrop *)',
     'Bash(bin/playdrop *)',
-    'Bash(/Users/*/PlayDropWorker/tasks/*/bin/playdrop *)',
     'Bash(node *)',
     'Bash(npm *)',
     'Bash(mkdir *)',
@@ -563,12 +567,7 @@ const CLAUDE_ALLOWED_PERMISSION_RULES = [
     'Bash(sips *)',
     'Bash(ls *)',
     'Bash(pwd)',
-    'Bash(cat *)',
-    'Bash(head *)',
-    'Bash(tail *)',
     'Bash(rg *)',
-    'Bash(grep *)',
-    'Bash(find *)',
     'Bash(which *)',
     'Bash(wc *)',
     'Bash(stat *)',
@@ -587,11 +586,27 @@ function normalizeClaudePermissionPath(value) {
     }
     return node_path_1.default.resolve(trimmed).replace(/\\/g, '/').replace(/\/+$/, '');
 }
-function buildClaudePermissionSettings(denyReadRoots = []) {
+function buildClaudeAllowedPermissionRules(workspaceDir) {
+    const workspaceRoot = typeof workspaceDir === 'string' && workspaceDir.trim()
+        ? normalizeClaudePermissionPath(workspaceDir)
+        : null;
+    if (!workspaceRoot) {
+        throw new Error('worker_claude_workspace_missing');
+    }
+    const absoluteWorkspacePattern = `//${workspaceRoot.replace(/^\/+/, '')}/**`;
+    return [
+        `Read(${absoluteWorkspacePattern})`,
+        `Edit(${absoluteWorkspacePattern})`,
+        `Write(${absoluteWorkspacePattern})`,
+        `Bash(${workspaceRoot}/bin/playdrop *)`,
+        ...CLAUDE_BUILD_PERMISSION_RULES,
+    ];
+}
+function buildClaudePermissionSettings(input = {}) {
     return {
         permissions: {
-            allow: [...CLAUDE_ALLOWED_PERMISSION_RULES],
-            deny: buildClaudeDeniedPermissionRules(denyReadRoots),
+            allow: buildClaudeAllowedPermissionRules(input.workspaceDir),
+            deny: buildClaudeDeniedPermissionRules(input.denyReadRoots ?? []),
         },
     };
 }
@@ -624,6 +639,34 @@ function buildWorkerChildEnv(input) {
             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;
+    }
+    if (input.claudeConfigDir !== undefined) {
+        const claudeConfigDir = input.claudeConfigDir.trim();
+        if (!claudeConfigDir || !node_path_1.default.isAbsolute(claudeConfigDir)) {
+            throw new Error('invalid_worker_child_claude_config_dir');
+        }
+        child.CLAUDE_CONFIG_DIR = claudeConfigDir;
+    }
+    if (input.playwrightBrowsersPath !== undefined) {
+        const playwrightBrowsersPath = input.playwrightBrowsersPath.trim();
+        if (!playwrightBrowsersPath || !node_path_1.default.isAbsolute(playwrightBrowsersPath)) {
+            throw new Error('invalid_worker_playwright_browsers_path');
+        }
+        child.PLAYWRIGHT_BROWSERS_PATH = playwrightBrowsersPath;
+    }
     child.PATH = typeof base.PATH === 'string' && base.PATH
         ? `${input.binDir}${node_path_1.default.delimiter}${base.PATH}`
         : input.binDir;

package/dist/commands/worker.d.ts

@@ -1,5 +1,6 @@
 import type { ApiClient } from '@playdrop/api-client';
-import { type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AgentWorkerCapabilities, type AgentWorkerResponse, type WorkerAgentTaskAssignmentResponse, type WorkerAgentTaskBaseSourceResponse, type WorkerAgentTaskWorkspaceFileResponse, type WorkerClaimAgentTaskResponse } from '@playdrop/types';
+import { type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AgentWorkerCapabilities, type AgentWorkerResponse, type AgentWorkerUpdatePolicyResponse, type WorkerAgentTaskAssignmentResponse, type WorkerAgentTaskBaseSourceResponse, type WorkerAgentTaskWorkspaceFileResponse, type WorkerClaimAgentTaskResponse } from '@playdrop/types';
+import { loadConfig } from '../config';
 import { type WorkerPlaydropAssetRequirement } from './upload';
 import { type LoggedProcessResult, type LoggedProcessTranscriptChunk } from './worker/runtime';
 export { assertWorkerTokenUsageWithinCap, buildClaudeExecArgs, buildClaudePermissionSettings, buildCodexExecArgs, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractCodexThreadId, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readCodexSandboxMode, readEnvBoolean, runLoggedProcess } from './worker/runtime';
@@ -11,6 +12,8 @@ type WorkerStartOptions = {
     once?: boolean;
     name?: string;
     superviseStdin?: boolean;
+    supervisor?: string;
+    devPluginWorkingTree?: string;
 };
 type WorkerStatusOptions = {
     env?: string;
@@ -33,12 +36,6 @@ type WorkerLocalStatus = {
         chromiumInstalled?: boolean;
         executablePath?: string;
     } | null;
-    plugin: {
-        ready: boolean;
-        root: string | null;
-        version: string | null;
-        error: string | null;
-    };
     agents: AgentWorkerCapabilities['agents'];
     capabilities: AgentWorkerCapabilities | null;
     setupActions: WorkerSetupAction[];
@@ -57,6 +54,7 @@ type WorkerStatusPayload = {
         reachable: boolean;
         authenticated: boolean;
         worker: AgentWorkerResponse | null;
+        updatePolicy?: AgentWorkerUpdatePolicyResponse;
         error?: string;
     };
 };
@@ -164,19 +162,25 @@ export declare function assertTaskUploadResultMatchesContext(input: {
     };
 }): void;
 export declare function stageAssignmentWorkspaceFiles(workspaceDir: string, files: readonly WorkerAgentTaskWorkspaceFileResponse[]): Promise<void>;
-export declare function resolvePlaydropPluginRoot(input?: {
-    homeDir?: string;
-    env?: NodeJS.ProcessEnv;
-}): string;
 export declare function stagePlaydropPluginReferences(input: {
     workspaceDir: string;
     pluginRoot: string;
     kind: AgentTaskKind;
 }): Promise<string[]>;
+export declare function stageCodexTaskSkills(input: {
+    workspaceDir: string;
+    stagedPluginPaths: readonly string[];
+}): Promise<string[]>;
+export declare function assertAssignmentPluginBundleExtractionBounds(buffer: Buffer): void;
 export declare function stageAssignmentPluginBundle(input: {
     workspaceDir: string;
     pluginBundle: NonNullable<WorkerAgentTaskAssignmentResponse['pluginBundle']>;
 }): Promise<string>;
+export declare function resolveDevPluginWorkingTree(input: {
+    workingTree?: string;
+    env: string;
+    nodeEnv?: string;
+}): string | null;
 export declare function discoverWorkerProjectRoot(workspaceDir: string): string;
 export declare function readWorkerTaskState(): WorkerTaskState | null;
 export declare function buildWorkerHealthAlertText(input: WorkerHealthAlertInput): string;
@@ -186,6 +190,7 @@ export declare function isWorkerTransientNetworkError(error: unknown): boolean;
 export declare function classifyWorkerHeartbeatError(error: unknown): 'session_expired' | 'lease_invalid' | 'transient_network' | null;
 export declare function assertWorkerClaimErrorRetryable(error: unknown): void;
 export declare function resolvePlaydropAssetRequirementFromText(value: unknown): WorkerPlaydropAssetRequirement | null;
+export declare function resolvePlaywrightBrowsersPathFromExecutable(executablePath: string): string;
 export declare function loadWorkerEnvFile(envName: string | undefined, cwd?: string): string | null;
 export declare function buildWorkerCapabilities(input: {
     codexVersion?: string | null;
@@ -227,6 +232,28 @@ export declare function assertWorkerProjectVersionBumped(input: {
     projectVersion: string;
     appName: string;
 }): void;
+export declare function prepareCodexRunHomes(input: {
+    workspaceDir: string;
+    workerUsername: string;
+    envName: string;
+    sourceCodexHome?: string;
+    playdropConfig?: ReturnType<typeof loadConfig>;
+}): Promise<{
+    homeDir: string;
+    codexHomeDir: string;
+}>;
+export declare function prepareClaudeRunConfig(input: {
+    workspaceDir: string;
+    workerUsername: string;
+    envName: string;
+    sourceCredentialsPath?: string;
+    playdropConfig?: ReturnType<typeof loadConfig>;
+}): Promise<{
+    homeDir: string;
+    claudeConfigDir: string;
+}>;
+export declare function removeAgentRunCredentials(workspaceDir: string): Promise<void>;
+export declare function removeStaleAgentRunCredentials(workerHomeDir?: string): Promise<void>;
 export declare function buildAgentFailureCode(agent: AgentRuntime, result: LoggedProcessResult): string;
 export declare function describeAgentFailureForEvent(errorCode: string): string;
 export declare function createLocalPlaydropShim(input: {
@@ -245,6 +272,7 @@ export declare function buildWorkerSetupActions(input: {
         executablePath?: string;
     } | null;
 }): WorkerSetupAction[];
+export declare function resolveWorkerStateDir(): string;
 type WorkerRuntimeState = {
     schemaVersion: 1;
     pid: number;
@@ -254,6 +282,30 @@ type WorkerRuntimeState = {
     target: AgentExecutionTarget;
     startedAt: string;
 };
+export type WorkerSupervisorType = 'app' | 'terminal';
+export type WorkerSupervisorLockOwner = {
+    schemaVersion: 1;
+    supervisorType: WorkerSupervisorType;
+    pid: number;
+    processStartIdentity: string;
+    workerName: string;
+    createdAt: string;
+};
+export type WorkerSupervisorLock = {
+    file: string;
+    owner: WorkerSupervisorLockOwner;
+};
+export declare function resolveWorkerSupervisorLockFile(input?: {
+    workerHomeDirectory?: string;
+}): string;
+export declare function parseLinuxProcessStartIdentity(stat: string): string | null;
+export declare function removeStaleWorkerSupervisorLockIfUnchanged(file: string, observedHolder: WorkerSupervisorLockOwner): boolean;
+export declare function acquireWorkerSupervisorLock(input: {
+    supervisorType: WorkerSupervisorType;
+    workerName: string;
+    file?: string;
+}): WorkerSupervisorLock;
+export declare function releaseWorkerSupervisorLock(lock: WorkerSupervisorLock): void;
 export declare function readActivePersonalWorkerRuntimeState(): WorkerRuntimeState | null;
 export declare function parseLaunchAgentProgramArguments(plist: string): string[];
 export declare function assertLaunchAgentPlistCompatible(input: {