@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/commands/worker/game-source-git.js

@@ -0,0 +1,780 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitGameSourceWorkerEvent = emitGameSourceWorkerEvent;
+exports.setupGameSourceWorkspace = setupGameSourceWorkspace;
+exports.checkpointFailedGameSourceWorkspace = checkpointFailedGameSourceWorkspace;
+exports.reconcileGameSourceWorkspace = reconcileGameSourceWorkspace;
+exports.finalizeGameSourceRepository = finalizeGameSourceRepository;
+exports.uploadFinalizedGameSource = uploadFinalizedGameSource;
+exports.maintainGameSourceCaches = maintainGameSourceCaches;
+exports.cleanupCompletedGameSourceWorkspace = cleanupCompletedGameSourceWorkspace;
+exports.readGameSourceWorkerInventory = readGameSourceWorkerInventory;
+const game_source_git_1 = require("@playdrop/game-source-git");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const REPO_CACHE_LIMIT_BYTES = 2 * 1024 * 1024 * 1024;
+const BLOB_CACHE_LIMIT_BYTES = 25 * 1024 * 1024 * 1024;
+const FAILED_WORKSPACE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const INVENTORY_LIMIT = 2000;
+const git = (0, game_source_git_1.createGitRunner)();
+function emitGameSourceWorkerEvent(event, fields, write = console.log) {
+    try {
+        write(JSON.stringify({ event, at: new Date().toISOString(), ...fields }));
+    }
+    catch {
+        // Operational visibility must never interrupt creator work.
+    }
+}
+function cacheRoot(workerHomeDir) {
+    return node_path_1.default.join(workerHomeDir, "game-source");
+}
+function repoCacheRoot(workerHomeDir) {
+    return node_path_1.default.join(cacheRoot(workerHomeDir), "repos");
+}
+function blobCacheRoot(workerHomeDir) {
+    return node_path_1.default.join(cacheRoot(workerHomeDir), "files");
+}
+function blobCachePath(workerHomeDir, key) {
+    const parts = key.split("/");
+    return node_path_1.default.join(blobCacheRoot(workerHomeDir), parts[parts.length - 2], parts[parts.length - 1]);
+}
+function normalizeRelativePath(root, absolutePath) {
+    return node_path_1.default.relative(root, absolutePath).split(node_path_1.default.sep).join("/");
+}
+function semanticVersion(version) {
+    return { major: version.major, minor: version.minor, patch: version.patch };
+}
+async function downloadBuffer(url, expectedBytes, expectedSha256) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`game_source_download_failed:${response.status}`);
+    const content = Buffer.from(await response.arrayBuffer());
+    if (expectedBytes !== undefined && content.length !== expectedBytes)
+        throw new Error("game_source_download_size_mismatch");
+    if (expectedSha256 !== undefined && (0, game_source_git_1.sha256)(content) !== expectedSha256) {
+        throw new Error("game_source_download_hash_mismatch");
+    }
+    return content;
+}
+async function uploadBuffer(upload, content) {
+    const response = await fetch(upload.url, {
+        method: "PUT",
+        headers: { ...upload.headers, "content-type": upload.contentType },
+        body: Uint8Array.from(content),
+    });
+    if (!response.ok)
+        throw new Error(`game_source_upload_failed:${response.status}`);
+}
+function expectedRefs(assignment) {
+    if (!assignment.baseRepository)
+        throw new Error("game_source_expected_head_missing");
+    return {
+        headSha: assignment.baseRepository.expectedHeadSha,
+        versions: assignment.authoritativeVersions.map((version) => ({
+            version: { major: version.major, minor: version.minor, patch: version.patch },
+            commitSha: version.commitSha,
+        })),
+    };
+}
+async function createBareCache(input) {
+    if (!input.assignment.baseRepository)
+        throw new Error("game_source_bundle_url_missing");
+    const bundlePath = node_path_1.default.join(input.workspaceDir, ".playdrop", `canonical-${(0, node_crypto_1.randomUUID)()}.bundle`);
+    const temporary = `${input.destination}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(bundlePath), { recursive: true });
+    try {
+        await (0, promises_1.writeFile)(bundlePath, await downloadBuffer(input.assignment.baseRepository.bundleDownloadUrl));
+        await git.run(["bundle", "verify", bundlePath]);
+        await git.run(["clone", "--bare", bundlePath, temporary]);
+        await reconcileCachedCanonicalRefs(temporary, input.assignment);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(input.destination), { recursive: true });
+        try {
+            await (0, promises_1.rename)(temporary, input.destination);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST" && error.code !== "ENOTEMPTY") {
+                throw error;
+            }
+        }
+    }
+    finally {
+        await (0, promises_1.rm)(bundlePath, { force: true });
+        await (0, promises_1.rm)(temporary, { recursive: true, force: true });
+    }
+}
+async function reconcileCachedCanonicalRefs(bareRepoPath, assignment) {
+    const expectedTags = new Set(assignment.authoritativeVersions.map((version) => (0, game_source_git_1.versionTagRef)(semanticVersion(version))));
+    const refs = await git.run(["--git-dir", bareRepoPath, "for-each-ref", "--format=%(refname)"], bareRepoPath);
+    for (const ref of refs.toString("utf8").trim().split("\n").filter(Boolean)) {
+        if (ref === "refs/heads/main")
+            continue;
+        if (/^refs\/heads\/task\/[1-9][0-9]*$/.test(ref))
+            continue;
+        if (!/^refs\/tags\/v(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)$/.test(ref)) {
+            throw new Error(`game_source_cache_unexpected_ref:${ref}`);
+        }
+        if (!expectedTags.has(ref))
+            await git.run(["--git-dir", bareRepoPath, "update-ref", "-d", ref], bareRepoPath);
+    }
+    await (0, game_source_git_1.validateCanonicalRefTargets)(bareRepoPath, expectedRefs(assignment), git);
+}
+async function prepareExistingBareCache(input) {
+    const repository = input.assignment.baseRepository;
+    if (!repository)
+        throw new Error("game_source_repository_identity_missing");
+    const { appId, repoGeneration } = repository;
+    const destination = node_path_1.default.join(repoCacheRoot(input.workerHomeDir), String(appId), `${repoGeneration}.git`);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        if (!(0, node_fs_1.existsSync)(destination))
+            await createBareCache({ ...input, destination });
+        try {
+            await reconcileCachedCanonicalRefs(destination, input.assignment);
+            return destination;
+        }
+        catch (error) {
+            const quarantine = `${destination}.quarantine-${Date.now()}-${(0, node_crypto_1.randomUUID)()}`;
+            await (0, promises_1.rename)(destination, quarantine).catch(() => undefined);
+            if (attempt === 1)
+                throw error;
+        }
+    }
+    throw new Error("game_source_cache_setup_failed");
+}
+async function prepareRemixBareRepository(input) {
+    if ((0, node_fs_1.existsSync)(input.destination))
+        return input.destination;
+    const temporary = `${input.destination}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(input.destination), { recursive: true });
+    try {
+        await git.run(["clone", "--bare", "--no-local", input.sourceBareRepoPath, temporary]);
+        const refs = await git.run(["--git-dir", temporary, "for-each-ref", "--format=%(refname)"], temporary);
+        for (const ref of refs.toString("utf8").trim().split("\n").filter(Boolean)) {
+            await git.run(["--git-dir", temporary, "update-ref", "-d", ref], temporary);
+        }
+        await (0, promises_1.rename)(temporary, input.destination);
+    }
+    finally {
+        await (0, promises_1.rm)(temporary, { recursive: true, force: true });
+    }
+    return input.destination;
+}
+async function addTaskWorktree(input) {
+    await git.run(["--git-dir", input.bareRepoPath, "worktree", "prune"]);
+    await git.run(["--git-dir", input.bareRepoPath, "branch", "-D", input.taskBranch]).catch(() => Buffer.alloc(0));
+    await (0, promises_1.rm)(input.projectDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(input.projectDir), { recursive: true });
+    if (input.startSha) {
+        await git.run(["--git-dir", input.bareRepoPath, "worktree", "add", "-b", input.taskBranch, input.projectDir, input.startSha]);
+    }
+    else {
+        await git.run(["--git-dir", input.bareRepoPath, "worktree", "add", "--orphan", "-b", input.taskBranch, input.projectDir]);
+    }
+}
+function linkedWorktreeAdminPath(projectDir, gitLink) {
+    const match = /^gitdir: (.+)\s*$/.exec(gitLink);
+    if (!match)
+        throw new Error("game_source_retained_workspace_link_invalid");
+    return node_path_1.default.resolve(projectDir, match[1]);
+}
+async function retainedWorktreeIsUsable(input) {
+    try {
+        const commonDir = await (0, promises_1.realpath)(node_path_1.default.resolve(input.projectDir, (await git.run(["rev-parse", "--git-common-dir"], input.projectDir)).toString("utf8").trim()));
+        const expectedCommonDir = await (0, promises_1.realpath)(input.bareRepoPath);
+        const branch = (await git.run(["symbolic-ref", "--short", "HEAD"], input.projectDir)).toString("utf8").trim();
+        return commonDir === expectedCommonDir && branch === input.taskBranch;
+    }
+    catch {
+        return false;
+    }
+}
+async function reattachRetainedWorktree(input) {
+    const staleGitLink = await (0, promises_1.readFile)(node_path_1.default.join(input.projectDir, ".git"), "utf8");
+    const staleAdminPath = linkedWorktreeAdminPath(input.projectDir, staleGitLink);
+    const expectedAdminRoot = `${node_path_1.default.join(await (0, promises_1.realpath)(input.bareRepoPath), "worktrees")}${node_path_1.default.sep}`;
+    if (!staleAdminPath.startsWith(expectedAdminRoot)) {
+        throw new Error("game_source_retained_workspace_repository_mismatch");
+    }
+    const temporaryProjectDir = `${input.projectDir}.reattach-${(0, node_crypto_1.randomUUID)()}`;
+    await addTaskWorktree({
+        bareRepoPath: input.bareRepoPath,
+        projectDir: temporaryProjectDir,
+        taskBranch: input.taskBranch,
+        startSha: input.startSha,
+    });
+    try {
+        const freshGitLink = await (0, promises_1.readFile)(node_path_1.default.join(temporaryProjectDir, ".git"), "utf8");
+        const freshAdminPath = linkedWorktreeAdminPath(temporaryProjectDir, freshGitLink);
+        await (0, promises_1.writeFile)(node_path_1.default.join(freshAdminPath, "gitdir"), `${node_path_1.default.join(input.projectDir, ".git")}\n`);
+        await (0, promises_1.writeFile)(node_path_1.default.join(input.projectDir, ".git"), freshGitLink);
+    }
+    finally {
+        await (0, promises_1.rm)(temporaryProjectDir, { recursive: true, force: true });
+    }
+    if (!await retainedWorktreeIsUsable(input)) {
+        throw new Error("game_source_retained_workspace_reattach_failed");
+    }
+}
+async function materializeCurrentLock(input) {
+    const lock = (0, game_source_git_1.parseGameSourceLock)(await (0, promises_1.readFile)(node_path_1.default.join(input.projectDir, ".playdrop", "files.lock")));
+    const requestedByKey = new Map();
+    for (const entry of Object.values(lock.files)) {
+        const existing = requestedByKey.get(entry.key);
+        if (existing && (existing.sha256 !== entry.sha256 || existing.bytes !== entry.bytes)) {
+            throw new Error("game_source_material_lock_conflict");
+        }
+        requestedByKey.set(entry.key, { sha256: entry.sha256, bytes: entry.bytes, key: entry.key });
+    }
+    const requested = [...requestedByKey.values()];
+    const response = requested.length > 0
+        ? await input.client.workerReadGameSourceFiles(input.taskId, {
+            workerKey: input.workerKey,
+            leaseToken: input.leaseToken,
+            files: requested,
+        })
+        : { files: [] };
+    const urlByKey = new Map(response.files.map((entry) => [entry.key, entry.downloadUrl]));
+    await (0, game_source_git_1.materializeGameSourceLock)({
+        rootDir: input.projectDir,
+        blobCacheDir: blobCacheRoot(input.workerHomeDir),
+        lock,
+        download: async (key) => {
+            const entry = Object.values(lock.files).find((candidate) => candidate.key === key);
+            const url = urlByKey.get(key);
+            if (!entry || !url)
+                throw new Error("game_source_material_url_missing");
+            return await downloadBuffer(url, entry.bytes, entry.sha256);
+        },
+    });
+}
+async function writeManagedGameSourceIgnore(projectDir) {
+    const ignorePath = node_path_1.default.join(projectDir, ".gitignore");
+    let existing = "";
+    try {
+        existing = await (0, promises_1.readFile)(ignorePath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    await (0, promises_1.writeFile)(ignorePath, (0, game_source_git_1.updateManagedGitignore)(existing));
+}
+async function setupGameSourceWorkspace(input) {
+    const setupStartedAt = Date.now();
+    const source = input.assignment.gameSource;
+    if (!source)
+        throw new Error("game_source_assignment_missing");
+    const taskBranch = `task/${input.assignment.task.id}`;
+    const projectDir = node_path_1.default.join(input.workspaceDir, "project");
+    const resumed = (0, node_fs_1.existsSync)(node_path_1.default.join(projectDir, ".git"));
+    const repositoryCache = resumed
+        ? "retained_workspace"
+        : source.baseRepository
+            ? (0, node_fs_1.existsSync)(node_path_1.default.join(repoCacheRoot(input.workerHomeDir), String(source.baseRepository.appId), `${source.baseRepository.repoGeneration}.git`))
+                ? "exact_hit"
+                : "miss"
+            : "new_repository";
+    emitGameSourceWorkerEvent("playdrop.game_source.setup_started", {
+        taskId: input.assignment.task.id,
+        appId: source.baseRepository?.appId ?? null,
+        repoGeneration: source.baseRepository?.repoGeneration ?? null,
+        repositoryCache,
+    });
+    const selectedBaseCommit = source.selectedBaseVersionId === null
+        ? null
+        : source.authoritativeVersions.find((version) => version.versionId === source.selectedBaseVersionId)?.commitSha ?? null;
+    const taskBaseSha = selectedBaseCommit ?? source.baseRepository?.selectedCommitSha ?? null;
+    const pendingMaterials = new Map();
+    let bareRepoPath;
+    if (source.baseRepository) {
+        const sourceBareRepoPath = await prepareExistingBareCache({
+            assignment: source,
+            workerHomeDir: input.workerHomeDir,
+            workspaceDir: input.workspaceDir,
+        });
+        bareRepoPath = source.mode === "REMIX"
+            ? await prepareRemixBareRepository({
+                sourceBareRepoPath,
+                destination: node_path_1.default.join(input.workspaceDir, ".playdrop", "remix-game.git"),
+            })
+            : sourceBareRepoPath;
+    }
+    else {
+        bareRepoPath = node_path_1.default.join(input.workspaceDir, ".playdrop", "new-game.git");
+        if (!(0, node_fs_1.existsSync)(bareRepoPath)) {
+            await (0, promises_1.mkdir)(node_path_1.default.dirname(bareRepoPath), { recursive: true });
+            await git.run(["init", "--bare", bareRepoPath]);
+        }
+    }
+    if (!resumed) {
+        await addTaskWorktree({
+            bareRepoPath,
+            projectDir,
+            taskBranch,
+            startSha: taskBaseSha,
+        });
+    }
+    else if (!await retainedWorktreeIsUsable({ bareRepoPath, projectDir, taskBranch })) {
+        await reattachRetainedWorktree({
+            bareRepoPath,
+            projectDir,
+            taskBranch,
+            startSha: taskBaseSha,
+        });
+    }
+    if (taskBaseSha && !resumed) {
+        await materializeCurrentLock({ ...input, projectDir, taskId: input.assignment.task.id });
+    }
+    if (source.listingSync && !resumed) {
+        const listingFiles = new Map();
+        for (const file of source.listingSync.files) {
+            listingFiles.set(file.path, await downloadBuffer(file.downloadUrl, file.bytes, file.sha256));
+        }
+        await (0, game_source_git_1.syncAuthoritativeListing)({
+            repoPath: projectDir,
+            listing: {
+                version: source.listingSync.version,
+                displayName: source.listingSync.displayName,
+                subtitle: source.listingSync.subtitle,
+                description: source.listingSync.description,
+                iconPath: source.listingSync.iconPath,
+                heroPortraitPath: source.listingSync.heroPortraitPath,
+                heroLandscapePath: source.listingSync.heroLandscapePath,
+                socialLandscapePath: source.listingSync.socialLandscapePath,
+                screenshotsPortrait: source.listingSync.screenshotsPortrait,
+                screenshotsLandscape: source.listingSync.screenshotsLandscape,
+                videosPortrait: source.listingSync.videosPortrait,
+                videosLandscape: source.listingSync.videosLandscape,
+                files: listingFiles,
+                updatedAt: new Date(source.listingSync.updatedAt),
+            },
+            putImmutableFile: async (key, content, contentSha256) => {
+                const cachePath = blobCachePath(input.workerHomeDir, key);
+                await (0, promises_1.mkdir)(node_path_1.default.dirname(cachePath), { recursive: true });
+                if (!(0, node_fs_1.existsSync)(cachePath))
+                    await (0, promises_1.writeFile)(cachePath, content, { flag: "wx" });
+                pendingMaterials.set(key, {
+                    path: key,
+                    sha256: contentSha256,
+                    bytes: content.length,
+                    key,
+                    content,
+                });
+            },
+        });
+    }
+    if (source.listingSync && !resumed) {
+        const healedLock = (0, game_source_git_1.parseGameSourceLock)(await (0, promises_1.readFile)(node_path_1.default.join(projectDir, ".playdrop", "files.lock")));
+        await (0, game_source_git_1.materializeGameSourceLock)({
+            rootDir: projectDir,
+            blobCacheDir: blobCacheRoot(input.workerHomeDir),
+            lock: healedLock,
+            download: async () => {
+                throw new Error("game_source_self_heal_blob_cache_missing");
+            },
+        });
+    }
+    await writeManagedGameSourceIgnore(projectDir);
+    const transcriptDir = node_path_1.default.join(projectDir, "transcripts");
+    for (const transcript of source.transcripts) {
+        await (0, promises_1.mkdir)(transcriptDir, { recursive: true });
+        await (0, promises_1.writeFile)(node_path_1.default.join(transcriptDir, `task-${transcript.taskId}-attempt-${transcript.attempt}.jsonl`), await downloadBuffer(transcript.downloadUrl, transcript.bytes, transcript.sha256));
+    }
+    const retainedMarkerDir = node_path_1.default.join(input.workspaceDir, ".playdrop");
+    await (0, promises_1.mkdir)(retainedMarkerDir, { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(retainedMarkerDir, "game-source-retained.json"), `${JSON.stringify({ taskId: input.assignment.task.id, attemptedAt: new Date().toISOString() })}\n`);
+    emitGameSourceWorkerEvent("playdrop.game_source.setup_completed", {
+        taskId: input.assignment.task.id,
+        appId: source.baseRepository?.appId ?? null,
+        repoGeneration: source.baseRepository?.repoGeneration ?? null,
+        repositoryCache,
+        durationMs: Date.now() - setupStartedAt,
+        selfHealVersionCount: 0,
+        transcriptCount: source.transcripts.length,
+    });
+    return {
+        assignment: source,
+        workspaceDir: input.workspaceDir,
+        projectDir,
+        bareRepoPath,
+        taskBranch,
+        baseHeadSha: taskBaseSha,
+        canonicalHeadSha: source.mode === "REMIX" ? null : source.baseRepository?.expectedHeadSha ?? null,
+        versions: source.mode === "REMIX" ? [] : source.authoritativeVersions,
+        healedVersionCommits: [],
+        pendingMaterials,
+    };
+}
+async function walkFiles(root, current = root) {
+    const files = [];
+    for (const entry of await (0, promises_1.readdir)(current, { withFileTypes: true })) {
+        if (entry.name === ".git")
+            continue;
+        const absolute = node_path_1.default.join(current, entry.name);
+        const relative = normalizeRelativePath(root, absolute);
+        if (entry.isDirectory()) {
+            if (["node_modules", "dist", "build", "coverage", ".next", ".playdrop-task-events"].includes(entry.name))
+                continue;
+            if (relative === ".playdrop" || relative.startsWith(".playdrop/"))
+                continue;
+            files.push(...await walkFiles(root, absolute));
+        }
+        else if (entry.isFile()) {
+            files.push(absolute);
+        }
+    }
+    return files;
+}
+async function gitCommit(repoPath, message) {
+    await git.run([
+        "-c", "user.name=Playdrop Game Source",
+        "-c", "user.email=game-source@playdrop.invalid",
+        "commit", "--allow-empty", "-m", message,
+    ], repoPath);
+    return (await git.run(["rev-parse", "HEAD"], repoPath)).toString("utf8").trim();
+}
+async function commitSanitizedGameSourceTree(input) {
+    const taskHead = await git.run(["rev-parse", "--verify", "HEAD"], input.repoPath)
+        .then((output) => output.toString("utf8").trim())
+        .catch(() => null);
+    if (input.baseHeadSha) {
+        if (!taskHead)
+            throw new Error("game_source_task_head_missing");
+        await git.run(["merge-base", "--is-ancestor", input.baseHeadSha, taskHead], input.repoPath);
+    }
+    const treeSha = (await git.run(["write-tree"], input.repoPath)).toString("utf8").trim();
+    const commitSha = (await git.run([
+        "-c", "user.name=Playdrop Game Source",
+        "-c", "user.email=game-source@playdrop.invalid",
+        "commit-tree", treeSha,
+        ...(input.baseHeadSha ? ["-p", input.baseHeadSha] : []),
+        "-m", input.message,
+    ], input.repoPath)).toString("utf8").trim();
+    await git.run(["update-ref", "HEAD", commitSha, taskHead ?? "0".repeat(40)], input.repoPath);
+    return commitSha;
+}
+async function stageGameSourceCommit(input) {
+    const gitFiles = new Map();
+    const materials = new Map();
+    const transcripts = [];
+    const excluded = [];
+    for (const absolute of await walkFiles(input.projectDir)) {
+        const relative = normalizeRelativePath(input.projectDir, absolute);
+        const content = await (0, promises_1.readFile)(absolute);
+        const classification = (0, game_source_git_1.classifyGameSourceFile)(relative, content);
+        if (classification === "git")
+            gitFiles.set(relative, content);
+        else if (classification === "material")
+            materials.set(relative, content);
+        else if (classification === "transcript")
+            transcripts.push(relative);
+        else
+            excluded.push(relative);
+    }
+    const lock = (0, game_source_git_1.createGameSourceLock)(materials);
+    await (0, promises_1.mkdir)(node_path_1.default.join(input.projectDir, ".playdrop"), { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(input.projectDir, ".playdrop", "files.lock"), (0, game_source_git_1.serializeGameSourceLock)(lock));
+    await writeManagedGameSourceIgnore(input.projectDir);
+    if (input.taskId !== undefined && input.summary !== undefined) {
+        await (0, promises_1.mkdir)(node_path_1.default.join(input.projectDir, "tasks"), { recursive: true });
+        await (0, promises_1.writeFile)(node_path_1.default.join(input.projectDir, "tasks", `${input.taskId}.md`), `${input.summary.trim()}\n`);
+    }
+    const hasHead = await git.run(["rev-parse", "--verify", "HEAD"], input.projectDir)
+        .then(() => true)
+        .catch(() => false);
+    if (hasHead)
+        await git.run(["add", "-u", "--", "."], input.projectDir);
+    for (const relative of [...materials.keys(), ...transcripts, ...excluded]) {
+        await git.run(["rm", "--cached", "--ignore-unmatch", "--", relative], input.projectDir);
+    }
+    for (const relative of [
+        ...gitFiles.keys(),
+        ".playdrop/files.lock",
+        ".gitignore",
+        ...(input.taskId === undefined ? [] : [`tasks/${input.taskId}.md`]),
+    ]) {
+        await git.run(["add", "--force", "--", relative], input.projectDir);
+    }
+    return { lock, materials };
+}
+async function checkpointFailedGameSourceWorkspace(input) {
+    const branch = (await git.run(["symbolic-ref", "--short", "HEAD"], input.workspace.projectDir))
+        .toString("utf8")
+        .trim();
+    if (branch !== input.workspace.taskBranch)
+        throw new Error("game_source_task_branch_changed");
+    await stageGameSourceCommit({ projectDir: input.workspace.projectDir });
+    return await gitCommit(input.workspace.projectDir, `Task ${input.taskId}: failed workspace checkpoint`);
+}
+async function reconcileGameSourceWorkspace(input) {
+    const { projectDir } = input.workspace;
+    if (input.workspace.assignment.baseRepository && input.workspace.assignment.mode !== "REMIX") {
+        try {
+            await (0, game_source_git_1.validateCanonicalRefTargets)(projectDir, expectedRefs(input.workspace.assignment), git);
+        }
+        catch {
+            await git.run([
+                "--git-dir",
+                input.workspace.bareRepoPath,
+                "worktree",
+                "remove",
+                "--force",
+                projectDir,
+            ]).catch(() => Buffer.alloc(0));
+            const quarantine = `${input.workspace.bareRepoPath}.quarantine-${Date.now()}-${(0, node_crypto_1.randomUUID)()}`;
+            await (0, promises_1.rename)(input.workspace.bareRepoPath, quarantine).catch(() => undefined);
+            throw new Error("game_source_ref_target_tampered");
+        }
+    }
+    const { lock, materials } = await stageGameSourceCommit({
+        projectDir,
+        taskId: input.taskId,
+        summary: input.summary,
+    });
+    const commitSha = await commitSanitizedGameSourceTree({
+        repoPath: projectDir,
+        baseHeadSha: input.workspace.baseHeadSha,
+        message: `Task ${input.taskId}: ${input.summary.trim()}`,
+    });
+    await (0, game_source_git_1.scanOutgoingObjects)({
+        repoPath: projectDir,
+        proposedRefs: [...new Set([commitSha, ...input.workspace.versions.map((version) => version.commitSha)])],
+        previousTargets: input.workspace.baseHeadSha
+            ? [
+                input.workspace.baseHeadSha,
+                ...input.workspace.assignment.authoritativeVersions.map((version) => version.commitSha),
+            ]
+            : [],
+    }, git);
+    const currentMaterials = Object.entries(lock.files).map(([filePath, entry]) => ({
+        path: filePath,
+        sha256: entry.sha256,
+        bytes: entry.bytes,
+        key: entry.key,
+        content: materials.get(filePath),
+    }));
+    const materialByUploadKey = new Map(input.workspace.pendingMaterials);
+    for (const material of currentMaterials)
+        materialByUploadKey.set(material.key, material);
+    const materialList = [...materialByUploadKey.values()];
+    return { workspace: input.workspace, commitSha, materials: materialList };
+}
+async function finalizeGameSourceRepository(input) {
+    const { workspace, commitSha } = input.reconciled;
+    const tagRef = (0, game_source_git_1.versionTagRef)(input.version);
+    const existingVersion = workspace.versions.find((version) => version.versionId === input.appVersionId);
+    const existingTagTarget = await git.run(["rev-parse", "--verify", tagRef], workspace.projectDir)
+        .then((output) => output.toString("utf8").trim())
+        .catch(() => null);
+    if (existingTagTarget !== commitSha) {
+        if (existingTagTarget && !existingVersion) {
+            throw new Error(`game_source_version_tag_conflict:${tagRef}`);
+        }
+        await git.run([
+            "update-ref",
+            tagRef,
+            commitSha,
+            existingTagTarget ?? "0".repeat(40),
+        ], workspace.projectDir);
+    }
+    const versions = [
+        ...workspace.versions.filter((version) => version.versionId !== input.appVersionId),
+        { versionId: input.appVersionId, ...input.version, commitSha },
+    ];
+    const canonical = versions.map((version) => ({
+        version: { major: version.major, minor: version.minor, patch: version.patch },
+        commitSha: version.commitSha,
+    }));
+    const bundlePath = node_path_1.default.join(workspace.workspaceDir, ".playdrop", `outgoing-${(0, node_crypto_1.randomUUID)()}.bundle`);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(bundlePath), { recursive: true });
+    const previousMain = workspace.canonicalHeadSha;
+    const zeroSha = "0".repeat(40);
+    await git.run(["update-ref", "refs/heads/main", commitSha, previousMain ?? zeroSha], workspace.projectDir);
+    let bundle;
+    try {
+        await (0, game_source_git_1.createCanonicalBundle)({
+            repoPath: workspace.projectDir,
+            outputPath: bundlePath,
+            expected: { headSha: commitSha, versions: canonical },
+        }, git);
+        bundle = await (0, promises_1.readFile)(bundlePath);
+    }
+    finally {
+        if (previousMain) {
+            await git.run(["update-ref", "refs/heads/main", previousMain, commitSha], workspace.projectDir);
+        }
+        else {
+            await git.run(["update-ref", "-d", "refs/heads/main", commitSha], workspace.projectDir);
+        }
+        await (0, promises_1.rm)(bundlePath, { force: true });
+    }
+    return { ...input.reconciled, bundle, bundleSha256: (0, game_source_git_1.sha256)(bundle), versions };
+}
+async function uploadFinalizedGameSource(input) {
+    const blobs = input.source.materials.map(({ sha256: contentSha, bytes, key }) => ({ sha256: contentSha, bytes, key }));
+    const targetBaseGeneration = input.source.workspace.assignment.targetRepository.repoGeneration;
+    const prepared = await input.client.workerPrepareGameSource(input.taskId, {
+        workerKey: input.workerKey,
+        leaseToken: input.leaseToken,
+        appId: input.appId,
+        appUploadSessionId: input.appUploadSessionId,
+        baseGeneration: targetBaseGeneration,
+        bundle: {
+            sha256: input.source.bundleSha256,
+            bytes: input.source.bundle.length,
+            headSha: input.source.commitSha,
+            commitSha: input.source.commitSha,
+            healedVersionCommits: input.source.workspace.healedVersionCommits,
+        },
+        blobs,
+    });
+    const materialByKey = new Map(input.source.materials.map((entry) => [entry.key, entry.content]));
+    for (const blob of prepared.blobs) {
+        if (!blob.upload)
+            continue;
+        const content = materialByKey.get(blob.key);
+        if (!content)
+            throw new Error("game_source_material_missing");
+        await uploadBuffer(blob.upload, content);
+    }
+    if (prepared.bundle.currentUpload)
+        await uploadBuffer(prepared.bundle.currentUpload, input.source.bundle);
+    if (prepared.bundle.previousUpload)
+        await uploadBuffer(prepared.bundle.previousUpload, input.source.bundle);
+    return {
+        attempt: input.attempt,
+        baseGeneration: targetBaseGeneration,
+        bundleSha256: input.source.bundleSha256,
+        bundleBytes: input.source.bundle.length,
+        bundleStorageKey: prepared.bundle.currentKey,
+        headSha: input.source.commitSha,
+        commitSha: input.source.commitSha,
+        healedVersionCommits: input.source.workspace.healedVersionCommits.filter(() => true),
+        blobs,
+    };
+}
+async function directorySize(root) {
+    let total = 0;
+    for (const entry of await (0, promises_1.readdir)(root, { withFileTypes: true }).catch(() => [])) {
+        const absolute = node_path_1.default.join(root, entry.name);
+        if (entry.isDirectory())
+            total += await directorySize(absolute);
+        else if (entry.isFile())
+            total += (await (0, promises_1.stat)(absolute)).size;
+    }
+    return total;
+}
+async function repoCacheEntryHasActiveWorktree(appDirectory) {
+    for (const child of await (0, promises_1.readdir)(appDirectory, { withFileTypes: true }).catch(() => [])) {
+        if (!child.isDirectory() || !child.name.endsWith(".git"))
+            continue;
+        const worktrees = await (0, promises_1.readdir)(node_path_1.default.join(appDirectory, child.name, "worktrees")).catch(() => []);
+        if (worktrees.length > 0)
+            return true;
+    }
+    return false;
+}
+async function enforceCacheLimit(root, limit) {
+    const entries = await (0, promises_1.readdir)(root, { withFileTypes: true }).catch(() => []);
+    const candidates = await Promise.all(entries.map(async (entry) => {
+        const absolute = node_path_1.default.join(root, entry.name);
+        const info = await (0, promises_1.stat)(absolute);
+        const active = root.endsWith(`${node_path_1.default.sep}repos`) && entry.isDirectory()
+            ? await repoCacheEntryHasActiveWorktree(absolute)
+            : false;
+        return { absolute, modified: info.mtimeMs, bytes: entry.isDirectory() ? await directorySize(absolute) : info.size, active };
+    }));
+    let total = candidates.reduce((sum, entry) => sum + entry.bytes, 0);
+    for (const entry of candidates.sort((left, right) => left.modified - right.modified)) {
+        if (total <= limit)
+            break;
+        if (entry.active)
+            continue;
+        await (0, promises_1.rm)(entry.absolute, { recursive: true, force: true });
+        total -= entry.bytes;
+    }
+}
+async function maintainGameSourceCaches(workerHomeDir) {
+    await Promise.all([
+        enforceCacheLimit(repoCacheRoot(workerHomeDir), REPO_CACHE_LIMIT_BYTES),
+        enforceCacheLimit(blobCacheRoot(workerHomeDir), BLOB_CACHE_LIMIT_BYTES),
+    ]);
+    const taskRoot = node_path_1.default.join(workerHomeDir, "tasks");
+    const cutoff = Date.now() - FAILED_WORKSPACE_RETENTION_MS;
+    for (const entry of await (0, promises_1.readdir)(taskRoot, { withFileTypes: true }).catch(() => [])) {
+        if (!entry.isDirectory())
+            continue;
+        const marker = node_path_1.default.join(taskRoot, entry.name, ".playdrop", "game-source-retained.json");
+        const info = await (0, promises_1.stat)(marker).catch(() => null);
+        if (info && info.mtimeMs < cutoff)
+            await (0, promises_1.rm)(node_path_1.default.join(taskRoot, entry.name), { recursive: true, force: true });
+    }
+}
+async function cleanupCompletedGameSourceWorkspace(input) {
+    await git.run(["update-ref", "refs/heads/main", input.headSha], input.workspace.projectDir);
+    const expectedTags = new Set(input.versions.map((version) => (0, game_source_git_1.versionTagRef)(semanticVersion(version))));
+    for (const version of input.versions) {
+        await git.run(["update-ref", (0, game_source_git_1.versionTagRef)(semanticVersion(version)), version.commitSha], input.workspace.projectDir);
+    }
+    const tagOutput = await git.run(["for-each-ref", "--format=%(refname)", "refs/tags"], input.workspace.projectDir);
+    for (const ref of tagOutput.toString("utf8").trim().split("\n").filter(Boolean)) {
+        if (!expectedTags.has(ref))
+            await git.run(["update-ref", "-d", ref], input.workspace.projectDir);
+    }
+    await git.run(["--git-dir", input.workspace.bareRepoPath, "worktree", "remove", "--force", input.workspace.projectDir]);
+    await git.run(["--git-dir", input.workspace.bareRepoPath, "branch", "-D", input.workspace.taskBranch]).catch(() => Buffer.alloc(0));
+    const destination = node_path_1.default.join(repoCacheRoot(input.workerHomeDir), String(input.appId), `${input.repoGeneration}.git`);
+    if (node_path_1.default.resolve(destination) !== node_path_1.default.resolve(input.workspace.bareRepoPath)) {
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+        await (0, promises_1.rm)(destination, { recursive: true, force: true });
+        await (0, promises_1.rename)(input.workspace.bareRepoPath, destination);
+    }
+    await (0, promises_1.rm)(input.workspace.workspaceDir, { recursive: true, force: true });
+}
+function readGameSourceWorkerInventory(workerHomeDir) {
+    const cachedRepositories = [];
+    const repoRoot = repoCacheRoot(workerHomeDir);
+    if ((0, node_fs_1.existsSync)(repoRoot)) {
+        for (const appEntry of (0, node_fs_1.readdirSync)(repoRoot, { withFileTypes: true })) {
+            const appId = Number(appEntry.name);
+            if (!appEntry.isDirectory() || !Number.isSafeInteger(appId) || appId <= 0)
+                continue;
+            for (const generationEntry of (0, node_fs_1.readdirSync)(node_path_1.default.join(repoRoot, appEntry.name), { withFileTypes: true })) {
+                const match = /^([1-9][0-9]*)\.git$/.exec(generationEntry.name);
+                if (generationEntry.isDirectory() && match?.[1])
+                    cachedRepositories.push({ appId, repoGeneration: match[1] });
+                if (cachedRepositories.length >= INVENTORY_LIMIT)
+                    break;
+            }
+            if (cachedRepositories.length >= INVENTORY_LIMIT)
+                break;
+        }
+    }
+    const retainedTaskIds = [];
+    const taskRoot = node_path_1.default.join(workerHomeDir, "tasks");
+    if ((0, node_fs_1.existsSync)(taskRoot)) {
+        for (const entry of (0, node_fs_1.readdirSync)(taskRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const marker = node_path_1.default.join(taskRoot, entry.name, ".playdrop", "game-source-retained.json");
+            if (!(0, node_fs_1.existsSync)(marker))
+                continue;
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(marker, "utf8"));
+                const taskId = Number(parsed.taskId);
+                if (Number.isSafeInteger(taskId) && taskId > 0)
+                    retainedTaskIds.push(taskId);
+            }
+            catch {
+                continue;
+            }
+            if (retainedTaskIds.length >= INVENTORY_LIMIT)
+                break;
+        }
+    }
+    return { cachedRepositories, retainedTaskIds };
+}