@playcraft/cli 0.1.33 → 0.1.35-prod

package/dist/workspace-runtime/production/dependencies.js

@@ -1,60 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { join } from 'node:path';
-const LOCKS = [
-    ['package-lock.json', 'npm'], ['npm-shrinkwrap.json', 'npm'], ['pnpm-lock.yaml', 'pnpm'],
-    ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun'],
-];
-const hash = (body) => createHash('sha256').update(body).digest('hex');
-async function optional(path) {
-    try {
-        return await readFile(path);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw error;
-    }
-}
-/** Resolve one locked toolchain. A conflicting lock or floating declaration never silently selects npm. */
-export async function resolveProductionDependencies(root) {
-    const packageBody = await readFile(join(root, 'package.json'));
-    const pkg = JSON.parse(packageBody.toString());
-    const bodies = new Map();
-    const managers = new Set();
-    for (const [name, manager] of LOCKS) {
-        const body = await optional(join(root, name));
-        if (body) {
-            bodies.set(name, body);
-            managers.add(manager);
-        }
-    }
-    if (!managers.size)
-        throw new Error('production_dependency_lock_required');
-    if (managers.size !== 1)
-        throw new Error('production_dependency_locks_conflict');
-    const manager = [...managers][0];
-    if (manager !== 'pnpm')
-        throw new Error('production_pnpm_required_convert_first');
-    const declared = typeof pkg.packageManager === 'string'
-        ? /^(npm|pnpm|yarn|bun)@(\d+\.\d+\.\d+)(?:\+sha(?:224|512)\.[a-fA-F0-9]+)?$/.exec(pkg.packageManager) : undefined;
-    if (pkg.packageManager !== undefined && !declared)
-        throw new Error('production_package_manager_declaration_invalid');
-    if (declared && declared[1] !== manager)
-        throw new Error('production_package_manager_lock_mismatch');
-    const modernYarn = false;
-    const pnpmLock = bodies.get('pnpm-lock.yaml')?.toString();
-    const oldPnpm = /^lockfileVersion:\s*['\"]?6(?:\.|['\"]?\s*$)/m.test(pnpmLock ?? '');
-    const version = declared?.[2] ?? (oldPnpm ? '8.15.9' : '9.15.9');
-    return { manager, version, reference: declared ? String(pkg.packageManager) : `${manager}@${version}`, modernYarn,
-        locks: Object.fromEntries([...bodies].map(([name, body]) => [name, hash(body)])), packageDigest: hash(packageBody) };
-}
-export async function verifyProductionDependencyLocks(root, policy) {
-    for (const [name] of LOCKS) {
-        const body = await optional(join(root, name));
-        if ((body ? hash(body) : undefined) !== policy.locks[name])
-            throw new Error('production_dependency_lock_changed');
-    }
-    if (hash(await readFile(join(root, 'package.json'))) !== policy.packageDigest)
-        throw new Error('production_dependency_manifest_changed');
-}

package/dist/workspace-runtime/production/native.js

@@ -1,203 +0,0 @@
-import { join } from 'node:path';
-import { lstat, mkdir } from 'node:fs/promises';
-import { hashOperationPayload, operationScopeKey, productionSessionId, transitionOperation } from '@playcraft/common/cloud-workspace/runtime';
-import { createCodexAppServerAdapter } from '../codex/app-server.js';
-import { ingestCollected, publishSourceEvents, recordNativeEvents } from '../server/dispatch.js';
-import { verifyProductionLease } from './storage.js';
-import { processBirth, stopProductionGroup } from './processes.js';
-import { openDirectoryToDevelopment } from '../workspaces/directory-access.js';
-import { loadWorkspaceMcpConfig } from '../codex/mcp-config.js';
-export async function runProductionNative(state, input, root, record, track) {
-    if (!input.model)
-        throw new Error('production_model_configuration_required');
-    const temporaryRoot = join(root, '.playcraft-temp');
-    const existing = await lstat(temporaryRoot).catch(error => {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw error;
-    });
-    if (existing && (!existing.isDirectory() || existing.isSymbolicLink()))
-        throw new Error('production_source_path_invalid');
-    await mkdir(temporaryRoot, { recursive: true });
-    await openDirectoryToDevelopment(temporaryRoot, (await lstat(root)).gid);
-    const groups = [];
-    const adapter = createCodexAppServerAdapter({ config: { ...state.config, workspaceMode: 'single', workspaceRoot: root },
-        command: process.env.PLAYCRAFT_PRODUCTION_CODEX_COMMAND,
-        homeDir: process.env.PLAYCRAFT_LAUNCHER_SOCKET
-            ? `/var/lib/playcraft/codex/production-${input.task.attemptId}` : join(state.config.stateDir, 'production-native', input.task.attemptId),
-        model: input.model.model, processGroup: true,
-        loadMcpConfig: () => loadWorkspaceMcpConfig(state, input.task.workspaceId),
-        fixedExecution: { cwd: root, approvalPolicy: 'never', sandboxPolicy: { type: 'workspaceWrite', writableRoots: [root],
-                networkAccess: true, excludeTmpdirEnvVar: true, excludeSlashTmp: true } },
-        fixedThreadConfig: { model: input.model.model, modelProvider: 'playcraft_production', config: {
-                approval_policy: 'never', sandbox_mode: 'workspace-write',
-                'sandbox_workspace_write.writable_roots': [root],
-                'sandbox_workspace_write.network_access': true,
-                'sandbox_workspace_write.exclude_tmpdir_env_var': true,
-                'sandbox_workspace_write.exclude_slash_tmp': true,
-                'shell_environment_policy.set': { PLAYCRAFT_TOOL_REQUEST_DIR: join(temporaryRoot, 'tool-requests'), PLAYCRAFT_SKIP_UPDATE_CHECK: '1',
-                    TMPDIR: temporaryRoot, npm_config_cache: join(temporaryRoot, 'npm-cache'), npm_config_store_dir: join(temporaryRoot, 'pnpm-store') },
-                'model_providers.playcraft_production': { name: 'PlayCraft Production', base_url: input.model.endpoint,
-                    wire_api: 'responses', requires_openai_auth: false, http_headers: { Authorization: `Bearer ${input.model.token}` } },
-            } },
-        onSkillProcessRestart: async (process) => {
-            const group = { pid: process.pid, birth: await processBirth(process.pid), stopped: false };
-            groups.push(group);
-            await record(group);
-        },
-    });
-    const sessionId = productionSessionId(input.task.attemptId);
-    const prompt = String(input.payload.prompt ?? '');
-    const now = new Date().toISOString();
-    const operation = {
-        operationId: `${input.task.attemptId}:generate`, clientRequestId: `${input.task.attemptId}:generate`,
-        environment: input.task.environment, userId: input.task.userId, workspaceId: input.task.workspaceId,
-        directoryName: input.directoryName, sessionId, kind: 'session.turn', status: 'dispatched',
-        generation: state.config.generation, runtimeEpoch: state.runtimeEpoch,
-        payloadHash: hashOperationPayload({ text: prompt }), createdAt: now, updatedAt: now,
-    };
-    const scopeKey = operationScopeKey(operation);
-    let collecting = Promise.resolve();
-    let notifying;
-    let pendingNotifications = [];
-    const notify = (events) => {
-        // Notifications only wake the source archive; every event already belongs to the durable journal.
-        pendingNotifications = [...pendingNotifications, ...events].slice(-100);
-        notifying ??= (async () => {
-            while (pendingNotifications.length) {
-                const page = pendingNotifications;
-                pendingNotifications = [];
-                await publishSourceEvents(state, page);
-            }
-        })().finally(() => {
-            notifying = undefined;
-            if (pendingNotifications.length)
-                notify([]);
-        });
-    };
-    let archiveError;
-    let shutdownError;
-    let cancelled = false;
-    let rootThreadId;
-    let rootTurnId;
-    let completedTurn;
-    let timeout;
-    let leaseCheck;
-    let completion;
-    const done = new Promise(resolve => { completion = resolve; });
-    track(async () => {
-        cancelled = true;
-        completion('unknown');
-        await adapter.close?.();
-        await collecting;
-    });
-    const unsubscribe = adapter.onCollected?.(event => {
-        if (event.kind === 'process_exit')
-            completion('unknown');
-        else {
-            const params = event.params && typeof event.params === 'object'
-                ? event.params : {};
-            // The prompt is recorded before dispatch; Codex may echo the same user message afterward.
-            if (params.item?.type !== 'userMessage' || params.threadId !== rootThreadId) {
-                collecting = collecting.then(async () => notify(await ingestCollected(state, {
-                    ...event, params: { ...params, directoryName: input.directoryName },
-                }, false))).catch(error => {
-                    archiveError ??= error;
-                    completion('unknown');
-                });
-            }
-        }
-        if (event.method === 'turn/completed') {
-            const value = event.params;
-            if (value.threadId === rootThreadId && value.turn?.id) {
-                completedTurn = value.turn;
-                if (value.turn.id === rootTurnId)
-                    completion(value.turn.status === 'completed' ? 'completed' : 'failed');
-            }
-        }
-    });
-    try {
-        await adapter.start();
-        const process = adapter.executionProcess?.();
-        if (!process)
-            throw new Error('production_process_not_started');
-        const group = { pid: process.pid, birth: await processBirth(process.pid), stopped: false };
-        groups.push(group);
-        await record(group);
-        const thread = await adapter.startThread({ sessionId, cwd: root });
-        rootThreadId = thread.threadId;
-        // A production thread lives in its own Codex home and must never resume through the main adapter.
-        await state.journal.putSession({ sessionId, workspaceId: input.task.workspaceId, directoryName: input.directoryName,
-            threadId: thread.threadId, cwd: root, recoverability: 'history_only', turnStatus: 'starting' });
-        const creation = { ...operation, operationId: `${input.task.attemptId}:session.create`,
-            clientRequestId: `${input.task.attemptId}:session.create`, kind: 'session.create', status: 'completed',
-            payloadHash: hashOperationPayload({}), nativeThreadId: thread.threadId };
-        await state.journal.putOperation(operationScopeKey(creation), creation);
-        await state.journal.putOperation(scopeKey, { ...operation, nativeThreadId: thread.threadId });
-        notify(await recordNativeEvents(state, creation, [{ type: 'session.created', occurredAt: now, payload: {
-                    sessionId, threadId: thread.threadId, batchId: input.task.batchId, attemptId: input.task.attemptId,
-                    taskId: input.task.taskId, readonly: true, recoverability: 'history_only',
-                } }], false));
-        notify(await recordNativeEvents(state, operation, [{ type: 'item/completed', occurredAt: now, payload: {
-                    item: { id: `${sessionId}-prompt`, type: 'userMessage', content: [{ type: 'text', text: prompt }] },
-                } }], false));
-        const turn = await adapter.startTurn({ sessionId, threadId: thread.threadId, text: prompt,
-            clientRequestId: operation.clientRequestId, persistReservation: async ({ nativeRequestId }) => {
-                await state.journal.putOperation(scopeKey, { ...operation, nativeThreadId: thread.threadId, nativeRequestId });
-            } });
-        if (turn.outcome !== 'accepted')
-            throw new Error(turn.outcome === 'failed' ? 'production_native_failed' : 'production_native_start_unknown');
-        rootTurnId = turn.turnId;
-        const reserved = state.journal.getOperation(scopeKey);
-        const released = await state.journal.bindTurn({ scopeKey, sessionId, threadId: thread.threadId, turnId: turn.turnId,
-            operation: transitionOperation(reserved, 'accepted', { nativeThreadId: thread.threadId, nativeTurnId: turn.turnId }) });
-        if (released.length)
-            notify(released);
-        if (completedTurn?.id === rootTurnId)
-            completion(completedTurn.status === 'completed' ? 'completed' : 'failed');
-        timeout = setTimeout(() => completion('unknown'), 30 * 60_000);
-        let checking = false;
-        let consecutiveLeaseFailures = 0;
-        leaseCheck = setInterval(() => {
-            if (checking)
-                return;
-            checking = true;
-            void verifyProductionLease(input).then(() => { consecutiveLeaseFailures = 0; }).catch(async () => {
-                consecutiveLeaseFailures += 1;
-                if (consecutiveLeaseFailures >= 2) {
-                    completion('unknown');
-                    await adapter.close?.().catch(() => undefined);
-                }
-            }).finally(() => { checking = false; });
-        }, 5000);
-        const status = await done;
-        if (status !== 'completed')
-            throw new Error(status === 'failed' ? 'production_native_failed' : 'production_native_unknown');
-    }
-    finally {
-        clearInterval(leaseCheck);
-        clearTimeout(timeout);
-        await adapter.close?.().catch(error => { shutdownError = error; });
-        unsubscribe?.();
-        await collecting;
-        for (const group of groups)
-            await record({ ...group, stopped: await stopProductionGroup(group) });
-        const latest = state.journal.getOperation(scopeKey);
-        if (latest && ['dispatched', 'accepted', 'uncertain'].includes(latest.status)) {
-            const status = cancelled ? 'interrupted' : 'failed';
-            await state.journal.putOperation(scopeKey, transitionOperation(latest, status, {
-                error: cancelled ? 'production_execution_stopped' : 'production_native_unknown',
-            }));
-            const session = state.journal.getSession(sessionId);
-            if (session) {
-                await state.journal.putSession({ ...session, turnStatus: status, turnBlock: undefined });
-                notify(await recordNativeEvents(state, latest, [{ type: `turn.${status}`, occurredAt: new Date().toISOString(),
-                        payload: { turnId: latest.nativeTurnId, error: cancelled ? 'production_execution_stopped' : 'production_native_unknown' } }], false));
-            }
-        }
-        if (archiveError)
-            throw new Error('production_chat_archive_failed');
-        if (shutdownError)
-            throw new Error('production_native_stop_unknown');
-    }
-}

package/dist/workspace-runtime/production/processes.js

@@ -1,86 +0,0 @@
-import { spawn, execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { readFile } from 'node:fs/promises';
-import { setTimeout as delay } from 'node:timers/promises';
-import { startLauncherProcess } from '../codex/launcher-client.js';
-export async function processBirth(pid) {
-    if (process.platform !== 'linux') {
-        return promisify(execFile)('ps', ['-p', String(pid), '-o', 'lstart='], { timeout: 2000 }).then(value => value.stdout.trim() || undefined, () => undefined);
-    }
-    try {
-        const stat = await readFile(`/proc/${pid}/stat`, 'utf8');
-        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19];
-    }
-    catch {
-        return undefined;
-    }
-}
-export function groupExited(pid) {
-    try {
-        process.kill(-pid, 0);
-        return false;
-    }
-    catch (error) {
-        return error.code === 'ESRCH';
-    }
-}
-export async function stopProductionGroup(record) {
-    if (record.stopped || groupExited(record.pid))
-        return true;
-    if (record.birth && await processBirth(record.pid) !== record.birth)
-        return false;
-    for (const signal of ['SIGTERM', 'SIGKILL']) {
-        try {
-            process.kill(-record.pid, signal);
-        }
-        catch { /* Recheck whether the whole group exited. */ }
-        const deadline = Date.now() + 2000;
-        while (Date.now() < deadline) {
-            if (groupExited(record.pid))
-                return true;
-            await delay(25);
-        }
-    }
-    return groupExited(record.pid);
-}
-/** Only the save stage receives repository credentials; build and install receive none. */
-export async function runProductionCommand(state, input) {
-    const launcher = !input.trusted ? process.env.PLAYCRAFT_LAUNCHER_SOCKET : undefined;
-    const launched = launcher ? await startLauncherProcess({ socketPath: launcher, processId: input.processId,
-        runtimeEpoch: state.runtimeEpoch, argv: ['/usr/bin/bash', '-lc', input.command], cwd: input.cwd, env: input.env ?? {} }) : undefined;
-    const local = launched ? undefined : spawn('bash', ['-lc', input.command], { cwd: input.cwd,
-        env: { PATH: process.env.PATH, HOME: state.config.stateDir, ...input.env }, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
-    const pid = launched?.pid ?? local?.pid;
-    if (!pid)
-        throw new Error('production_process_not_started');
-    const record = { pid, birth: await processBirth(pid), stopped: false };
-    try {
-        await input.record(record);
-    }
-    catch (error) {
-        await stopProductionGroup(record);
-        throw error;
-    }
-    let output = '';
-    const collect = (chunk) => { output = (output + String(chunk)).slice(-64 * 1024); };
-    (launched?.stdout ?? local.stdout).on('data', collect);
-    (launched?.stderr ?? local.stderr).on('data', collect);
-    launched?.stdin?.end();
-    let timedOut = false;
-    const code = await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            void (launched ? launched.stop() : stopProductionGroup(record)).catch(() => undefined).finally(() => resolve(undefined));
-        }, input.timeoutMs);
-        const finish = (code) => { clearTimeout(timeout); resolve(code); };
-        if (launched)
-            launched.onExit(finish);
-        else {
-            local.once('error', () => finish(undefined));
-            local.once('close', finish);
-        }
-    });
-    const stopped = await stopProductionGroup(record);
-    await input.record({ ...record, stopped });
-    return { code: timedOut ? undefined : code, output, stopped };
-}

package/dist/workspace-runtime/production/save-command.js

@@ -1,35 +0,0 @@
-export function productionSaveCommand() {
-    return `set -eu
-status=0
-remote=$(git -c protocol.version=0 -c core.hooksPath=/dev/null ls-remote --exit-code --heads "$PRODUCTION_REPOSITORY" "refs/heads/$PRODUCTION_BRANCH") || status=$?
-if [ "$status" != 0 ] && [ "$status" != 2 ]; then exit "$status"; fi
-if [ "\${PRODUCTION_EXPECTED_PARENT+x}" = x ]; then
-  actual=$(printf '%s' "$remote" | cut -f1)
-  test "$actual" = "$PRODUCTION_EXPECTED_PARENT" || { printf 'production_git_parent_changed\\n' >&2; exit 1; }
-fi
-if [ -n "$remote" ]; then
-  parent=$(printf '%s' "$remote" | cut -f1)
-  git -c protocol.version=0 -c core.hooksPath=/dev/null fetch --no-tags --no-recurse-submodules "$PRODUCTION_REPOSITORY" "refs/heads/$PRODUCTION_BRANCH"
-  test "$(git rev-parse FETCH_HEAD)" = "$parent"
-  git -c core.hooksPath=/dev/null -c core.fsmonitor=false reset --soft FETCH_HEAD
-fi
-git -c core.hooksPath=/dev/null -c core.fsmonitor=false add -A .
-if [ -n "$(git ls-files -- .playcraft.json playcraft.config.json ':(glob)**/.playcraft.json' ':(glob)**/playcraft.config.json')" ]; then
-  printf 'production_git_private_path\\n' >&2
-  exit 1
-fi
-git diff --cached --quiet || git -c core.hooksPath=/dev/null commit -m "Save generated engineering"
-git -c protocol.version=0 -c core.hooksPath=/dev/null -c remote.origin.url="$PRODUCTION_REPOSITORY" -c remote.origin.pushurl="$PRODUCTION_REPOSITORY" push --set-upstream origin HEAD:"refs/heads/$PRODUCTION_BRANCH"
-git rev-parse HEAD`;
-}
-/** Commits generated engineering locally inside the sandbox without pushing a branch to remote origin. */
-export function productionLocalCommitCommand() {
-    return `set -eu
-git -c core.hooksPath=/dev/null -c core.fsmonitor=false add -A .
-if [ -n "$(git ls-files -- .playcraft.json playcraft.config.json ':(glob)**/.playcraft.json' ':(glob)**/playcraft.config.json')" ]; then
-  printf 'production_git_private_path\\n' >&2
-  exit 1
-fi
-git diff --cached --quiet || git -c core.hooksPath=/dev/null commit -m "Save generated engineering"
-git rev-parse HEAD`;
-}

package/dist/workspace-runtime/production/source-copy.js

@@ -1,91 +0,0 @@
-import { execFile } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, mkdir, open, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative } from 'node:path';
-import { promisify } from 'node:util';
-import { excludeFromGit } from '../workspaces/dependencies.js';
-const execute = promisify(execFile);
-const privateNames = new Set(['.git', 'node_modules', '.ssh', '.aws', '.azure', '.gnupg', '.codex', '.npm', '.pnpm-store',
-    '.config', '.npmrc', '.yarnrc', '.yarnrc.yml', '.netrc', '.git-credentials', 'credentials.json', 'credentials', 'secrets',
-    'id_rsa', 'id_ed25519', 'settings.local.json', '.playcraft.json', 'playcraft.config.json', '.playcraft-temp', '.playcraft-preview-out']);
-const engineering = (path) => !path.split('/').some(name => privateNames.has(name)
-    || /^\.env(?:$|\.)/.test(name) || /\.(?:pem|key|p12|pfx)$/.test(name)) && !path.startsWith('.playcraft/skills/');
-const inside = (root, path) => { const rel = relative(root, path); return rel !== '..' && !rel.startsWith('../') && !isAbsolute(rel); };
-const git = async (root, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'credential.helper=',
-    '-c', 'core.fsmonitor=false', '-C', root, ...args], { timeout: 90_000, maxBuffer: 64 * 1024 * 1024,
-    env: { PATH: process.env.PATH, HOME: dirname(root), GIT_OPTIONAL_LOCKS: '0', GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' } })).stdout;
-async function sourceFiles(root) {
-    const paths = new Set((await git(root, 'ls-files', '--cached', '--others', '--exclude-standard', '-z')).split('\0').filter(Boolean));
-    const artifacts = await readdir(join(root, '.playcraft/skill-artifacts')).catch(error => {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    });
-    for (const name of artifacts)
-        if (/^[a-f0-9]{64}\.tar\.gz$/.test(name))
-            paths.add(`.playcraft/skill-artifacts/${name}`);
-    const files = new Map();
-    for (const path of [...paths].sort()) {
-        if (!engineering(path))
-            continue;
-        const full = join(root, path), stat = await lstat(full).catch(error => {
-            if (error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        });
-        if (!stat)
-            continue;
-        if (!stat.isFile() || stat.isSymbolicLink() || !inside(root, await realpath(full)))
-            throw new Error('production_source_path_invalid');
-        const handle = await open(full, constants.O_RDONLY | constants.O_NOFOLLOW);
-        try {
-            files.set(path, { body: await handle.readFile(), mode: stat.mode & 0o777 });
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    return files;
-}
-function digest(files) {
-    const hash = createHash('sha256');
-    for (const [path, file] of files)
-        hash.update(path).update('\0').update(String(file.mode)).update('\0').update(file.body).update('\0');
-    return hash.digest('hex');
-}
-/** Capture the selected working tree into a private branch; the source index, head and configuration are read only. */
-export async function copyProductionSource(input) {
-    const source = await realpath(input.source);
-    if (await lstat(input.destination).catch(() => undefined))
-        throw new Error('production_source_destination_exists');
-    const sourceHead = await git(source, 'rev-parse', '--verify', 'HEAD').catch(() => '');
-    const files = await sourceFiles(source), sourceDigest = digest(files);
-    const staging = join(dirname(input.destination), `.production-source-${randomUUID()}`);
-    try {
-        await mkdir(staging);
-        // An independent root commit also excludes credentials that existed only in source history.
-        await git(staging, '-c', 'init.templateDir=', 'init', '--initial-branch', input.branchName);
-        for (const [path, file] of files) {
-            await mkdir(dirname(join(staging, path)), { recursive: true });
-            await writeFile(join(staging, path), file.body, { mode: file.mode, flag: 'wx' });
-        }
-        if (sourceHead !== await git(source, 'rev-parse', '--verify', 'HEAD').catch(() => '') || sourceDigest !== digest(await sourceFiles(source)))
-            throw new Error('production_source_changed');
-        await git(staging, 'remote', 'add', 'origin', input.repositoryUrl);
-        await git(staging, 'config', 'user.name', 'PlayCraft');
-        await git(staging, 'config', 'user.email', 'playcraft@localhost');
-        await excludeFromGit(staging);
-        await excludeFromGit(staging, '/.env*');
-        for (const entry of ['/.playcraft.json', '/playcraft.config.json', '/.playcraft/skill-artifacts/', '/.playcraft/skills/', '/.playcraft-temp/'])
-            await excludeFromGit(staging, entry);
-        await git(staging, 'add', '-A', '.');
-        await git(staging, 'commit', '--allow-empty', '-m', 'Capture batch source in independent remix');
-        const commitHash = (await git(staging, 'rev-parse', 'HEAD')).trim();
-        await rename(staging, input.destination);
-        return { commitHash, sourceDigest };
-    }
-    finally {
-        await rm(staging, { recursive: true, force: true });
-    }
-}