@playcraft/cli 0.1.31 → 0.1.33

package/dist/workspace-runtime/workspaces/attachment-content.js

@@ -4,6 +4,8 @@ import { extname } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { attachmentIdsSchema, attachmentUploadSchema, WORKSPACE_ATTACHMENT_MAX_BYTES, WORKSPACE_USER_UPLOADS_DIRECTORY, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES, } from '@playcraft/common/cloud-workspace/runtime';
 import { artifactMime, artifactPath } from './artifact-files.js';
+import { openLibraryAttachmentFile, readLibraryAttachmentMetadata } from './library-attachments.js';
+import { openWorkspaceDirectoryFile, readWorkspaceDirectoryMetadata } from './directory-attachments.js';
 const additionalMediaTypes = {
     '.aac': 'audio/aac', '.opus': 'audio/ogg', '.oga': 'audio/ogg', '.aif': 'audio/aiff', '.aiff': 'audio/aiff',
     '.bmp': 'image/bmp', '.ico': 'image/vnd.microsoft.icon', '.heic': 'image/heic', '.heif': 'image/heif',
@@ -24,13 +26,13 @@ function attachmentRange(header, size) {
     const end = first === undefined ? size - 1 : Math.min(last ?? size - 1, size - 1);
     return start >= size || start > end ? null : { start, end };
 }
-async function openAttachment(root, id) {
+async function openAttachment(root, id, filePath) {
     const metadataPath = await artifactPath(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata/${id}.json`);
     const metadataFile = await open(metadataPath, constants.O_RDONLY | constants.O_NOFOLLOW);
     let metadata;
     try {
         const stat = await metadataFile.stat();
-        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 8192)
+        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
             throw new Error('attachment_unavailable');
         metadata = JSON.parse(await metadataFile.readFile('utf8'));
         if (metadata.id !== id || !attachmentUploadSchema.shape.name.safeParse(metadata.name).success)
@@ -39,6 +41,16 @@ async function openAttachment(root, id) {
     finally {
         await metadataFile.close();
     }
+    if (metadata.origin?.kind === 'asset-library') {
+        const library = await readLibraryAttachmentMetadata(root, id);
+        return openLibraryAttachmentFile(root, library, filePath);
+    }
+    if (metadata.kind === 'directory') {
+        const directory = await readWorkspaceDirectoryMetadata(root, id);
+        return openWorkspaceDirectoryFile(root, directory, filePath);
+    }
+    if (filePath !== undefined)
+        throw new Error('attachment_unavailable');
     const path = await artifactPath(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}/${metadata.name}`);
     const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
@@ -56,7 +68,7 @@ async function openAttachment(root, id) {
     }
 }
 /** Serve only registered references; no caller-supplied file paths reach the filesystem. */
-export async function serveWorkspaceAttachment(root, attachmentId, request, response) {
+export async function serveWorkspaceAttachment(root, attachmentId, request, response, filePath) {
     if (!attachmentIdsSchema.safeParse([attachmentId]).success) {
         response.writeHead(400, { 'content-type': 'application/json', 'cache-control': 'no-store' });
         response.end(JSON.stringify({ error: 'invalid_attachment' }));
@@ -64,7 +76,7 @@ export async function serveWorkspaceAttachment(root, attachmentId, request, resp
     }
     let content;
     try {
-        content = await openAttachment(root, attachmentId);
+        content = await openAttachment(root, attachmentId, filePath);
     }
     catch {
         response.writeHead(404, { 'content-type': 'application/json', 'cache-control': 'no-store' });

package/dist/workspace-runtime/workspaces/attachments.js

@@ -6,6 +6,8 @@ import { WORKSPACE_USER_UPLOADS_DIRECTORY, attachmentIdsSchema, attachmentUpload
 import { NativePreparationError } from '../codex/native-adapter.js';
 import { excludeFromGit } from './dependencies.js';
 import { hashAttachment, probeAttachmentVideo } from './video-attachments.js';
+import { resolveLibraryAttachment } from './library-attachments.js';
+import { resolveWorkspaceDirectoryAttachment } from './directory-attachments.js';
 async function attachmentRoot(root) {
     // Reject redirected upload directories, including symlinks that stay inside the workspace.
     let directory = root;
@@ -136,13 +138,17 @@ export async function resolveWorkspaceAttachments(root, input) {
             let metadata;
             try {
                 const stat = await metadataHandle.stat();
-                if (!stat.isFile() || stat.nlink !== 1 || stat.size > 8192)
+                if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
                     throw new Error('invalid_attachment');
                 metadata = JSON.parse(await metadataHandle.readFile('utf8'));
             }
             finally {
                 await metadataHandle.close();
             }
+            if (metadata.origin?.kind === 'asset-library')
+                return resolveLibraryAttachment(root, id);
+            if (metadata.kind === 'directory')
+                return resolveWorkspaceDirectoryAttachment(root, id);
             attachmentUploadSchema.shape.name.parse(metadata.name);
             if (metadata.id !== id)
                 throw new Error('invalid_attachment');

package/dist/workspace-runtime/workspaces/directories.js

@@ -11,6 +11,7 @@ import { readDependencies, scheduleDependencyInstall } from './dependencies.js';
 import { revisionScope } from './registry.js';
 import { ensureWorkspaceSkills } from './skills.js';
 import { checkoutBatchCommit, freezeBatchCommit } from './batch-commit.js';
+import { ensureWorkspaceArtifactInstructions } from './instructions.js';
 const execute = promisify(execFile);
 /** Trusted Runtime registration clones an immutable local commit; it never follows basic's current branch head. */
 export async function registerWorkspaceDirectory(state, input, leaseFence, sourceDirectoryName) {
@@ -68,6 +69,7 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
                 await rm(staging, { recursive: true, force: true });
             }
         }
+        await ensureWorkspaceArtifactInstructions(root);
         await openDirectoryToDevelopment(root, (await lstat(state.config.workspaceRoot)).gid);
         await state.journal.exclusive(`workspace:${directory.workspaceId}`, async () => {
             state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, leaseFence);
@@ -87,8 +89,12 @@ export async function restoreWorkspaceDirectory(state, workspaceId, directoryNam
     await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
         const binding = state.journal.getWorkspace(workspaceId);
         const directory = binding?.directories?.find(item => item.directoryName === directoryName);
-        if (!binding || directory?.status !== 'reclaimed')
+        if (!binding)
             return;
+        if (directory?.status !== 'reclaimed') {
+            await ensureWorkspaceArtifactInstructions(await workspaceRoot(state, workspaceId, directoryName));
+            return;
+        }
         if (binding.targetKind === 'standalone' || !state.gitCredentials)
             throw new WorkspaceContextError('workspace_recovery_required');
         const preparation = await state.gitCredentials.prepareDirectory(workspaceId, directoryName);
@@ -98,6 +104,7 @@ export async function restoreWorkspaceDirectory(state, workspaceId, directoryNam
         if (!await lstat(root).catch(() => undefined))
             await prepareWorkspaceCheckout(state, target, preparation, state.acceptedLeaseFence, directoryName, true);
         await ensureWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'));
+        await ensureWorkspaceArtifactInstructions(root);
         await openDirectoryToDevelopment(root, (await lstat(state.config.workspaceRoot)).gid);
         await state.journal.putWorkspace({ ...binding, directories: binding.directories?.map(item => item.directoryName === directoryName ? { ...item, status: 'ready' } : item) });
         try {

package/dist/workspace-runtime/workspaces/directory-attachments.js

@@ -0,0 +1,245 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { attachmentIdsSchema, WORKSPACE_USER_UPLOADS_DIRECTORY, WORKSPACE_ATTACHMENT_MAX_BYTES, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES, WORKSPACE_DIRECTORY_ATTACHMENT_MAX_BYTES, workspaceAttachmentSchema, workspaceDirectoryAttachmentUploadSchema, workspaceDirectoryAttachmentFilePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { artifactMime } from './artifact-files.js';
+import { excludeFromGit } from './dependencies.js';
+import { hashAttachment, probeAttachmentVideo } from './video-attachments.js';
+const stagingPath = `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.directory-uploads`;
+const locks = new Map();
+async function withUploadLock(root, id, action) {
+    const key = `${root}\0${id}`;
+    const previous = locks.get(key) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(action);
+    locks.set(key, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (locks.get(key) === current)
+            locks.delete(key);
+    }
+}
+async function safeDirectory(root, relative, create = false) {
+    let directory = root;
+    for (const part of relative.split('/')) {
+        directory = join(directory, part);
+        if (create)
+            await mkdir(directory, { mode: 0o755 }).catch((error) => {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            });
+        if (!(await lstat(directory)).isDirectory())
+            throw new Error('invalid_attachment');
+    }
+    return directory;
+}
+function validId(id) {
+    if (!attachmentIdsSchema.safeParse([id]).success)
+        throw new Error('invalid_attachment');
+}
+async function readManifest(root, id) {
+    validId(id);
+    const stage = await safeDirectory(root, `${stagingPath}/${id}`);
+    const handle = await open(join(stage, 'manifest.json'), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
+            throw new Error('invalid_attachment');
+        return workspaceDirectoryAttachmentUploadSchema.parse(JSON.parse(await handle.readFile('utf8')));
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function beginWorkspaceDirectoryAttachment(root, body) {
+    const manifest = workspaceDirectoryAttachmentUploadSchema.parse(body);
+    await excludeFromGit(root, `/${WORKSPACE_USER_UPLOADS_DIRECTORY}/`);
+    const staging = await safeDirectory(root, stagingPath, true);
+    const id = randomUUID();
+    const stage = join(staging, id);
+    await mkdir(stage, { mode: 0o755 });
+    try {
+        await mkdir(join(stage, 'data'), { mode: 0o755 });
+        await mkdir(join(stage, 'data', manifest.name), { mode: 0o755 });
+        await writeFile(join(stage, 'manifest.json'), JSON.stringify(manifest), { flag: 'wx', mode: 0o644 });
+        return { uploadId: id };
+    }
+    catch (error) {
+        await rm(stage, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** Each member is streamed and created exclusively; no completed member can be overwritten. */
+export async function uploadWorkspaceDirectoryFile(root, id, path, request) {
+    return withUploadLock(root, id, async () => {
+        workspaceDirectoryAttachmentFilePathSchema.parse(path);
+        const manifest = await readManifest(root, id);
+        const member = manifest.files.find(file => file.path === path);
+        if (!member)
+            throw new Error('invalid_attachment');
+        const length = request.headers['content-length'];
+        if (length !== undefined && (!/^\d+$/.test(length) || Number(length) !== member.size))
+            throw new Error('invalid_attachment');
+        const relative = `${stagingPath}/${id}/data/${manifest.name}/${path}`;
+        await safeDirectory(root, dirname(relative), true);
+        const handle = await open(join(root, relative), constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | constants.O_NOFOLLOW, 0o644);
+        try {
+            let size = 0;
+            for await (const chunk of request) {
+                const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                if (size + bytes.length > member.size)
+                    throw new Error('invalid_attachment');
+                let offset = 0;
+                while (offset < bytes.length)
+                    offset += (await handle.write(bytes, offset, bytes.length - offset, size + offset)).bytesWritten;
+                size += bytes.length;
+            }
+            if (size !== member.size)
+                throw new Error('invalid_attachment');
+            await handle.sync();
+            if (member.mimeType.startsWith('video/')) {
+                const media = await probeAttachmentVideo(handle);
+                if (media.mimeType !== member.mimeType && !(member.mimeType === 'video/quicktime' && media.mimeType === 'video/mp4'))
+                    throw new Error('invalid_attachment');
+            }
+            return { path, size };
+        }
+        catch (error) {
+            await rm(join(root, relative), { force: true });
+            throw error;
+        }
+        finally {
+            await handle.close();
+        }
+    });
+}
+async function assertExactFiles(directory, expected, prefix = '') {
+    for (const name of await readdir(directory)) {
+        const relative = prefix ? `${prefix}/${name}` : name;
+        const path = join(directory, name);
+        const stat = await lstat(path);
+        if (stat.isDirectory())
+            await assertExactFiles(path, expected, relative);
+        else if (!stat.isFile() || stat.nlink !== 1 || !expected.delete(relative))
+            throw new Error('invalid_attachment');
+    }
+    if (!prefix && expected.size)
+        throw new Error('invalid_attachment');
+}
+async function directoryFiles(root, relative, manifest) {
+    const directory = await safeDirectory(root, relative);
+    await assertExactFiles(directory, new Set(manifest.files.map(file => file.path)));
+    const files = [];
+    for (const file of manifest.files) {
+        await safeDirectory(directory, dirname(file.path) === '.' ? '' : dirname(file.path));
+        const handle = await open(join(directory, file.path), constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.nlink !== 1 || stat.size !== file.size)
+                throw new Error('invalid_attachment');
+            const media = file.mimeType.startsWith('video/') ? await probeAttachmentVideo(handle) : undefined;
+            if (media && media.mimeType !== file.mimeType && !(file.mimeType === 'video/quicktime' && media.mimeType === 'video/mp4'))
+                throw new Error('invalid_attachment');
+            const inferred = artifactMime(file.path);
+            files.push({ path: file.path, size: stat.size, sha256: await hashAttachment(handle),
+                mimeType: media?.mimeType ?? (inferred === 'application/octet-stream' ? file.mimeType : inferred) });
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    return files;
+}
+export async function completeWorkspaceDirectoryAttachment(root, id) {
+    return withUploadLock(root, id, async () => {
+        const manifest = await readManifest(root, id);
+        const stage = await safeDirectory(root, `${stagingPath}/${id}`);
+        const files = await directoryFiles(root, `${stagingPath}/${id}/data/${manifest.name}`, manifest);
+        const metadata = await safeDirectory(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata`, true);
+        const uploads = await safeDirectory(root, WORKSPACE_USER_UPLOADS_DIRECTORY);
+        const attachment = { id, name: manifest.name, kind: 'directory',
+            size: files.reduce((size, file) => size + file.size, 0), mimeType: 'application/vnd.playcraft.directory',
+            path: `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}/${manifest.name}`, files };
+        workspaceAttachmentSchema.parse(attachment);
+        const target = join(uploads, id);
+        await mkdir(target, { mode: 0o755 });
+        try {
+            await rename(join(stage, 'data', manifest.name), join(target, manifest.name));
+            await writeFile(join(metadata, `${id}.json`), JSON.stringify(attachment), { flag: 'wx', mode: 0o644 });
+        }
+        catch (error) {
+            await rm(target, { recursive: true, force: true });
+            throw error;
+        }
+        await rm(stage, { recursive: true, force: true });
+        return attachment;
+    });
+}
+export async function cancelWorkspaceDirectoryAttachment(root, id) {
+    validId(id);
+    return withUploadLock(root, id, async () => {
+        const parent = await safeDirectory(root, stagingPath);
+        const stage = join(parent, id);
+        try {
+            if (!(await lstat(stage)).isDirectory())
+                throw new Error('invalid_attachment');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await rm(stage, { recursive: true, force: true });
+        return { uploadId: id, cancelled: true };
+    });
+}
+export async function readWorkspaceDirectoryMetadata(root, id) {
+    validId(id);
+    const metadata = await safeDirectory(root, `${WORKSPACE_USER_UPLOADS_DIRECTORY}/.metadata`);
+    const handle = await open(join(metadata, `${id}.json`), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
+            throw new Error('invalid_attachment');
+        const attachment = workspaceAttachmentSchema.parse(JSON.parse(await handle.readFile('utf8')));
+        if (attachment.id !== id || attachment.kind !== 'directory' || attachment.origin || !attachment.files ||
+            attachment.path !== `${WORKSPACE_USER_UPLOADS_DIRECTORY}/${id}/${attachment.name}` || attachment.mimeType !== 'application/vnd.playcraft.directory')
+            throw new Error('invalid_attachment');
+        workspaceDirectoryAttachmentUploadSchema.parse({ name: attachment.name, files: attachment.files.map(({ sha256: _digest, ...file }) => file) });
+        if (attachment.size !== attachment.files.reduce((size, file) => size + file.size, 0) || attachment.size > WORKSPACE_DIRECTORY_ATTACHMENT_MAX_BYTES)
+            throw new Error('invalid_attachment');
+        return attachment;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function openWorkspaceDirectoryFile(root, attachment, path) {
+    workspaceDirectoryAttachmentFilePathSchema.parse(path);
+    const file = attachment.files?.find(file => file.path === path);
+    if (!file || !attachment.path)
+        throw new Error('attachment_unavailable');
+    const directory = await safeDirectory(root, attachment.path);
+    if (dirname(file.path) !== '.')
+        await safeDirectory(directory, dirname(file.path));
+    const handle = await open(join(directory, file.path), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat();
+        const limit = file.mimeType.startsWith('video/') ? WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES : WORKSPACE_ATTACHMENT_MAX_BYTES;
+        if (!stat.isFile() || stat.nlink !== 1 || stat.size !== file.size || stat.size > limit || await hashAttachment(handle) !== file.sha256)
+            throw new Error('attachment_unavailable');
+        return { handle, name: file.path.split('/').at(-1), mimeType: file.mimeType, size: file.size };
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}
+export async function resolveWorkspaceDirectoryAttachment(root, id) {
+    const attachment = await readWorkspaceDirectoryMetadata(root, id);
+    const files = await directoryFiles(root, attachment.path, { name: attachment.name, files: attachment.files.map(({ sha256: _digest, ...file }) => file) });
+    if (files.some((file, index) => file.sha256 !== attachment.files[index].sha256 || file.mimeType !== attachment.files[index].mimeType))
+        throw new Error('attachment_unavailable');
+    return { ...attachment, path: join(root, attachment.path) };
+}

package/dist/workspace-runtime/workspaces/git.js

@@ -1,9 +1,10 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { excludeFromGit } from './dependencies.js';
-import { lstat, readFile, realpath, stat, unlink } from 'node:fs/promises';
+import { copyFile, lstat, readFile, realpath, rm, stat, unlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
-import { WORKSPACE_FILE_CONTENT_MAX, gitDiffSchema, gitFileContentSchema, gitGraphSchema, gitStatusSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { TURN_CHANGED_FILES_MAX, WORKSPACE_FILE_CONTENT_MAX, gitDiffSchema, gitFileContentSchema, gitGraphSchema, gitStatusSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
 const GIT_DIFF_MAX_BYTES = 1024 * 1024;
 const GIT_PREFIX = [
     '-c',
@@ -43,6 +44,7 @@ export async function readWorkspaceGitStatus(root) {
         ahead = Number.parseInt(right ?? '0', 10) || 0;
     }
     const porcelain = await git(rootReal, ['status', '--porcelain=v1', '--untracked-files=all', '-z']);
+    const merge = await mergeState(rootReal);
     // Line counts are a convenience; a repository without commits still lists its files.
     const [staged, unstaged] = await Promise.all([
         gitAllowFail(rootReal, ['diff', '--cached', '--numstat', '-z']),
@@ -56,6 +58,7 @@ export async function readWorkspaceGitStatus(root) {
         ahead,
         behind,
         hasUpstream: upstream.code === 0,
+        ...merge,
         files: parsePorcelain(porcelain).map((entry) => ({
             ...entry,
             ...(stagedCounts.has(entry.path) ? { staged: stagedCounts.get(entry.path) } : {}),
@@ -63,14 +66,75 @@ export async function readWorkspaceGitStatus(root) {
         })),
     });
 }
+const SNAPSHOT_TIMEOUT_MS = 120_000;
 /**
- * One file as stored in the last commit or in the index. Reads the blob as is, without filters,
- * so the browser compares exactly what Git holds.
+ * Writes the work tree, as `git add -A` would stage it, to a tree object without touching the
+ * repository's own index or history. A copy of the index keeps its stat cache, so unchanged files
+ * are not hashed again. Ignored files and credential files are left out of the snapshot.
+ */
+export async function snapshotWorkspaceTree(root) {
+    const rootReal = await existingWorkspaceGit(root);
+    const env = { GIT_INDEX_FILE: join(rootReal, '.git', `playcraft-snapshot-${randomUUID()}.index`) };
+    const run = async (args) => {
+        const result = await runGitProcess(rootReal, [...GIT_PREFIX, `--git-dir=${join(rootReal, '.git')}`,
+            `--work-tree=${rootReal}`, ...args], SNAPSHOT_TIMEOUT_MS, env);
+        if (result.code !== 0)
+            throw new GitWorkspaceError('git_command_failed', result.stderr.trim() || `git_exit_${result.code}`);
+        return result.stdout;
+    };
+    try {
+        await copyFile(join(rootReal, '.git', 'index'), env.GIT_INDEX_FILE).catch((error) => {
+            if (error.code !== 'ENOENT')
+                throw error;
+        });
+        await run(['add', '-A']);
+        const credentials = (await run(['ls-files', '-z'])).split('\0').filter((path) => path && isCredentialFile(path));
+        if (credentials.length)
+            await run(['rm', '--cached', '--quiet', '--', ...credentials]);
+        return (await run(['write-tree'])).trim();
+    }
+    finally {
+        await rm(env.GIT_INDEX_FILE, { force: true });
+    }
+}
+/** Keeps a turn's snapshots from being pruned, so its changes stay readable after Git cleans up. */
+export async function retainTurnSnapshots(root, turnId, before, after) {
+    const rootReal = await existingWorkspaceGit(root);
+    const name = turnId.replace(/[^A-Za-z0-9_-]/g, '_');
+    await git(rootReal, ['update-ref', `refs/playcraft/turns/${name}/before`, before]);
+    await git(rootReal, ['update-ref', `refs/playcraft/turns/${name}/after`, after]);
+}
+/** The files that differ between two snapshot trees, with line counts for text files. */
+export async function diffWorkspaceTrees(root, before, after) {
+    const rootReal = await existingWorkspaceGit(root);
+    const diff = (format) => git(rootReal, ['diff-tree', '-r', '-z', '--no-renames', format, before, after], 60000);
+    const [statuses, counts] = await Promise.all([diff('--name-status'), diff('--numstat')]);
+    const lines = new Map();
+    for (const entry of counts.split('\0')) {
+        const match = /^(\d+|-)\t(\d+|-)\t(.+)$/s.exec(entry);
+        if (!match)
+            continue;
+        const binary = match[1] === '-';
+        lines.set(match[3], { added: binary ? 0 : Number(match[1]), removed: binary ? 0 : Number(match[2]), binary });
+    }
+    const parts = statuses.split('\0');
+    const files = [];
+    for (let index = 0; index + 1 < parts.length; index += 2) {
+        const status = parts[index] === 'A' ? 'added' : parts[index] === 'D' ? 'deleted' : 'modified';
+        const path = parts[index + 1];
+        files.push({ path, status, ...(lines.get(path) ?? { added: 0, removed: 0, binary: false }) });
+    }
+    return { files: files.slice(0, TURN_CHANGED_FILES_MAX), truncated: files.length > TURN_CHANGED_FILES_MAX };
+}
+/**
+ * One file as stored in the last commit, in the index or in a turn snapshot. Reads the blob as is,
+ * without filters, so the browser compares exactly what Git holds.
  */
 export async function readWorkspaceGitFile(root, path, ref) {
     const rootReal = await ensureWorkspaceGit(root);
     assertWorkspacePaths([path]);
-    const object = ref === 'HEAD' ? `HEAD:${path}` : `:${path}`;
+    const stage = { INDEX: 0, MERGE_BASE: 1, MERGE_OURS: 2, MERGE_THEIRS: 3 }[ref];
+    const object = stage === undefined ? `${ref}:${path}` : `:${stage}:${path}`;
     const absent = gitFileContentSchema.parse({ path, ref, exists: false, binary: false, content: '' });
     const size = await gitAllowFail(rootReal, ['cat-file', '-s', object]);
     if (size.code !== 0)
@@ -210,6 +274,9 @@ function pushRejection(stdout) {
 export async function commitWorkspaceGit(root, payload, boundBranch) {
     const rootReal = await ensureWorkspaceGit(root);
     await assertBoundBranch(rootReal, boundBranch);
+    // Adding a conflicted file would mark it resolved with its conflict markers in it.
+    if ((await unmergedPaths(rootReal)).length)
+        throw new GitWorkspaceError('git_conflicts_unresolved', 'unmerged');
     if (payload.stagedOnly) {
         // The index is the commit; nothing is added.
     }
@@ -273,6 +340,10 @@ export function isCredentialFile(path) {
 export async function saveWorkspaceGit(root, input) {
     const rootReal = await ensureWorkspaceGit(root);
     await assertBoundBranch(rootReal, input.boundBranch);
+    // A save during a merge would stage conflict markers as resolutions and conclude the merge. The
+    // user (or an agent) finishes the merge with an explicit commit; saves resume after it.
+    if ((await mergeState(rootReal)).merging)
+        return { pushed: false, withheld: [] };
     await git(rootReal, ['add', '-A'], 60000);
     const staged = (await git(rootReal, ['diff', '--cached', '--name-only', '-z'], 60000)).split('\0').filter(Boolean);
     const withheld = staged.filter(isCredentialFile);
@@ -292,6 +363,68 @@ export async function saveWorkspaceGit(root, input) {
     await recordPushedHead(rootReal);
     return { ...(commit ? { commit } : {}), pushed: true, withheld };
 }
+/**
+ * `git pull` with a merge, as VS Code runs it: fetch the bound branch from origin, then merge it.
+ * Uncommitted work is kept unless the incoming commits change the same files, in which case Git
+ * refuses before touching anything. Conflicts leave the merge in progress for the user to resolve.
+ */
+export async function pullWorkspaceGit(root, boundBranch) {
+    const rootReal = await ensureWorkspaceGit(root);
+    await assertBoundBranch(rootReal, boundBranch);
+    if ((await mergeState(rootReal)).merging)
+        throw new GitWorkspaceError('git_merge_in_progress', 'merge_in_progress');
+    if ((await gitAllowFail(rootReal, ['remote', 'get-url', 'origin'])).code !== 0) {
+        throw new GitWorkspaceError('remote_not_configured', 'origin');
+    }
+    const branch = (await gitAllowFail(rootReal, ['symbolic-ref', '--quiet', '--short', 'HEAD'])).stdout.trim();
+    const born = (await gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', 'HEAD^{commit}'])).code === 0;
+    if (!branch || !born)
+        throw new GitWorkspaceError('git_command_failed', 'git_branch_required');
+    // A fork clone has no fetch refspec for its own branch, so the tracking ref is named here.
+    const remoteRef = `refs/remotes/origin/${branch}`;
+    const fetched = await gitAllowFail(rootReal, ['fetch', '--no-tags', 'origin', `+refs/heads/${branch}:${remoteRef}`], 90000);
+    if (fetched.code !== 0)
+        throw new GitWorkspaceError(httpRefusal(fetched.stderr) ?? 'git_fetch_failed', 'git_fetch_failed');
+    if ((await gitAllowFail(rootReal, ['merge-base', '--is-ancestor', remoteRef, 'HEAD'])).code === 0) {
+        return { outcome: 'up_to_date', conflicts: [] };
+    }
+    // The short name gives the merge commit the message `git pull` would write.
+    const merged = await gitAllowFail(rootReal, [...(await commitIdentity(rootReal)), 'merge', '--no-edit', `origin/${branch}`], 60000);
+    if (merged.code === 0)
+        return { outcome: 'merged', conflicts: [] };
+    const conflicts = await unmergedPaths(rootReal);
+    if (conflicts.length)
+        return { outcome: 'conflicts', conflicts };
+    if (/would be overwritten by merge|untracked working tree files would be (?:overwritten|removed)/i.test(`${merged.stdout}\n${merged.stderr}`)) {
+        throw new GitWorkspaceError('git_pull_local_changes', 'local_changes');
+    }
+    throw new GitWorkspaceError('git_command_failed', merged.stderr.trim() || 'git_merge_failed');
+}
+/** `git merge --abort`: the work tree and index return to how they were before the merge began. */
+export async function abortWorkspaceMerge(root) {
+    const rootReal = await ensureWorkspaceGit(root);
+    if (!(await mergeState(rootReal)).merging)
+        throw new GitWorkspaceError('git_merge_not_in_progress', 'no_merge');
+    await git(rootReal, ['merge', '--abort'], 60000);
+}
+/** Paths with unmerged index entries, that is, conflicts not yet marked resolved. */
+async function unmergedPaths(rootReal) {
+    const listed = await gitAllowFail(rootReal, ['diff', '--name-only', '--diff-filter=U', '-z']);
+    return listed.code === 0 ? listed.stdout.split('\0').filter(Boolean) : [];
+}
+async function mergeState(rootReal) {
+    try {
+        await stat(join(rootReal, '.git', 'MERGE_HEAD'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+    const message = await readFile(join(rootReal, '.git', 'MERGE_MSG'), 'utf8').catch(() => '');
+    const text = message.split('\n').filter((line) => !line.startsWith('#')).join('\n').trim().slice(0, 4096);
+    return { merging: true, ...(text ? { mergeMessage: text } : {}) };
+}
 /**
  * Connects a standalone checkout to the repository it was just given, keeping all its history and
  * uncommitted work. The new repository holds one empty commit on `branch`; it becomes the base of an
@@ -382,6 +515,14 @@ export async function ensureWorkspaceGit(root) {
     await excludeFromGit(rootReal, '/.tmp/user_uploads/');
     return rootReal;
 }
+/** Turn snapshots never create a repository; a directory without one simply has no turn changes. */
+async function existingWorkspaceGit(root) {
+    const rootReal = await realpath(root);
+    if (!(await gitMarkerExists(rootReal)))
+        throw new GitWorkspaceError('git_command_failed', 'not_a_repository');
+    await assertWorkspaceGitRoot(rootReal);
+    return rootReal;
+}
 async function gitMarkerExists(rootReal) {
     try {
         await stat(join(rootReal, '.git'));
@@ -481,9 +622,9 @@ function gitEnv() {
     env.GIT_TERMINAL_PROMPT = '0';
     return env;
 }
-function runGitProcess(cwd, args, timeoutMs) {
+function runGitProcess(cwd, args, timeoutMs, env) {
     return new Promise((resolve, reject) => {
-        const child = spawn('git', args, { cwd, env: gitEnv(), windowsHide: true });
+        const child = spawn('git', args, { cwd, env: { ...gitEnv(), ...env }, windowsHide: true });
         // Chunks are decoded together; a character split across two chunks would otherwise be corrupted.
         const stdout = [];
         const stderr = [];

package/dist/workspace-runtime/workspaces/instructions.js

@@ -0,0 +1,56 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { chmod, lstat, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { resolveCliPackageRoot } from '../../scaffold/compose.js';
+const START = '<!-- playcraft:workspace-artifacts:start -->';
+const END = '<!-- playcraft:workspace-artifacts:end -->';
+/** Refresh only the platform-owned section; project and user instructions remain intact. */
+export async function ensureWorkspaceArtifactInstructions(root) {
+    const template = await readFile(join(resolveCliPackageRoot(), 'project-templates/empty/AGENTS.md'), 'utf8');
+    const start = template.indexOf(START), end = template.indexOf(END, start);
+    if (start < 0 || end < start)
+        throw new Error('workspace_instructions_invalid');
+    const section = template.slice(start, end + END.length);
+    const path = join(root, 'AGENTS.md');
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK).catch(error => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    let previous = '', mode = 0o664;
+    try {
+        if (handle) {
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024 * 1024)
+                throw new Error('workspace_instructions_invalid');
+            mode = stat.mode & 0o777;
+            previous = await handle.readFile('utf8');
+        }
+    }
+    finally {
+        await handle?.close();
+    }
+    const existingStart = previous.indexOf(START), existingEnd = previous.indexOf(END);
+    if ((existingStart < 0) !== (existingEnd < 0) || existingEnd < existingStart ||
+        previous.indexOf(START, existingStart + START.length) >= 0 || previous.indexOf(END, existingEnd + END.length) >= 0)
+        throw new Error('workspace_instructions_invalid');
+    const next = existingStart >= 0
+        ? previous.slice(0, existingStart) + section + previous.slice(existingEnd + END.length)
+        : `${previous}${previous ? (previous.endsWith('\n') ? '\n' : '\n\n') : '# PlayCraft Workspace\n\n'}${section}\n`;
+    if (next === previous)
+        return;
+    const temporary = join(root, `.AGENTS.${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, next, { flag: 'wx', mode });
+        await chmod(temporary, mode);
+        const current = await lstat(path).catch(error => { if (error.code === 'ENOENT')
+            return undefined; throw error; });
+        if (current && (!current.isFile() || current.isSymbolicLink() || current.nlink !== 1))
+            throw new Error('workspace_instructions_invalid');
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}