@playcraft/cli 0.1.11 → 0.1.12

package/dist/workspace-runtime/server/http.js

@@ -11,6 +11,11 @@ import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitFile, readWork
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
 import { readDependencies } from '../workspaces/dependencies.js';
 import { desktopHost, desktopRoute } from './desktop-host.js';
+import { ensureCliCredentials } from '../workspaces/cli-credentials.js';
+import { readAttachmentUpload, uploadWorkspaceAttachment } from '../workspaces/attachments.js';
+import { readWorkspaceSkills } from '../workspaces/skills.js';
+import { loadWorkspaceSkillArtifact } from '../workspaces/skill-artifact-loader.js';
+import { join } from 'node:path';
 import { terminalHost } from './terminal-host.js';
 export async function handleRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
@@ -59,6 +64,8 @@ export async function handleRuntimeRequest(state, request, response) {
                 return;
             }
             const binding = await registerWorkspace(state, parsed.data.binding, parsed.data.leaseFence, parsed.data.preparation);
+            if (parsed.data.cliCredentials)
+                await ensureCliCredentials(state);
             writeJson(response, 200, { workspaceId: binding.workspaceId, status: 'registered' });
             return;
         }
@@ -108,6 +115,19 @@ export async function handleRuntimeRequest(state, request, response) {
             await handleSourceEvents(state, request, response, url);
             return;
         }
+        if (request.method === 'POST' && url.pathname === '/runtime/attachments') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId') ?? '';
+            const root = await workspaceRoot(state, workspaceId);
+            try {
+                writeJson(response, 200, await uploadWorkspaceAttachment(root, await readAttachmentUpload(request)));
+            }
+            catch {
+                writeJson(response, 400, { error: 'invalid_attachment' });
+            }
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/files') {
             if (writeDestroyed(state, response))
                 return;
@@ -163,6 +183,21 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, 200, readDependencies(state, workspaceId ?? 'workspace'));
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/skills') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            try {
+                const view = await state.journal.exclusive(`workspace:${revisionScope(state, workspaceId) ?? 'single'}`, async () => readWorkspaceSkills(await workspaceRoot(state, workspaceId), join(state.config.stateDir, 'skill-artifacts'), entry => loadWorkspaceSkillArtifact(state, workspaceId ?? 'workspace', entry)));
+                writeJson(response, 200, view);
+            }
+            catch (error) {
+                if (error instanceof WorkspaceContextError)
+                    throw error;
+                writeJson(response, 409, { error: error instanceof Error && error.message.startsWith('workspace_skills_') ? error.message : 'workspace_skills_unavailable' });
+            }
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/git/graph') {
             await writeGitRead(state, response, async () => readWorkspaceGitGraph(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined)));
             return;

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

@@ -0,0 +1,109 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { chmod, lstat, mkdir, open, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { WORKSPACE_USER_UPLOADS_DIRECTORY, attachmentIdsSchema, attachmentUploadSchema, WORKSPACE_ATTACHMENT_MAX_BYTES, } from '@playcraft/common/cloud-workspace/runtime';
+import { NativePreparationError } from '../codex/native-adapter.js';
+import { excludeFromGit } from './dependencies.js';
+async function attachmentRoot(root) {
+    // Reject redirected upload directories, including symlinks that stay inside the workspace.
+    let directory = root;
+    for (const part of WORKSPACE_USER_UPLOADS_DIRECTORY.split('/')) {
+        directory = join(directory, part);
+        await mkdir(directory, { mode: 0o755 }).catch((error) => {
+            if (error.code !== 'EEXIST')
+                throw error;
+        });
+        if (!(await lstat(directory)).isDirectory())
+            throw new Error('invalid_attachment');
+        await chmod(directory, 0o755);
+    }
+    return directory;
+}
+function imageMime(bytes) {
+    if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        return 'image/png';
+    if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255)
+        return 'image/jpeg';
+    if (/^GIF8[79]a$/.test(bytes.subarray(0, 6).toString('ascii')))
+        return 'image/gif';
+    if (bytes.subarray(0, 4).toString() === 'RIFF' && bytes.subarray(8, 12).toString() === 'WEBP')
+        return 'image/webp';
+    return 'application/octet-stream';
+}
+export async function readAttachmentUpload(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += bytes.length;
+        if (size > 4 * Math.ceil(WORKSPACE_ATTACHMENT_MAX_BYTES / 3) + 4096)
+            throw new Error('invalid_attachment');
+        chunks.push(bytes);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+/** References belong to the workspace and are retained by its checkpoints. */
+export async function uploadWorkspaceAttachment(root, body) {
+    const parsed = attachmentUploadSchema.parse(body);
+    const bytes = Buffer.from(parsed.content, 'base64');
+    if (bytes.length > WORKSPACE_ATTACHMENT_MAX_BYTES || bytes.toString('base64') !== parsed.content)
+        throw new Error('invalid_attachment');
+    const attachment = {
+        id: randomUUID(),
+        name: parsed.name,
+        size: bytes.length,
+        mimeType: imageMime(bytes),
+    };
+    await excludeFromGit(root, `/${WORKSPACE_USER_UPLOADS_DIRECTORY}/`);
+    const uploads = await attachmentRoot(root);
+    const directory = join(uploads, attachment.id);
+    const metadataDirectory = join(uploads, '.metadata');
+    await mkdir(metadataDirectory, { mode: 0o755 }).catch((error) => {
+        if (error.code !== 'EEXIST')
+            throw error;
+    });
+    if (!(await lstat(metadataDirectory)).isDirectory())
+        throw new Error('invalid_attachment');
+    // Codex can run as a different user from the sandbox control process.
+    await mkdir(directory, { mode: 0o755 });
+    await writeFile(join(directory, attachment.name), bytes, { flag: 'wx', mode: 0o644 });
+    await writeFile(join(metadataDirectory, `${attachment.id}.json`), JSON.stringify(attachment), {
+        flag: 'wx',
+        mode: 0o644,
+    });
+    return attachment;
+}
+export async function resolveWorkspaceAttachments(root, input) {
+    try {
+        const ids = attachmentIdsSchema.parse(input ?? []);
+        return await Promise.all(ids.map(async (id) => {
+            const uploads = await attachmentRoot(root);
+            const directory = join(uploads, id);
+            if (!(await lstat(directory)).isDirectory())
+                throw new Error('invalid_attachment');
+            await chmod(directory, 0o755);
+            if (!(await lstat(join(uploads, '.metadata'))).isDirectory())
+                throw new Error('invalid_attachment');
+            const metadata = JSON.parse(await readFile(join(uploads, '.metadata', `${id}.json`), 'utf8'));
+            attachmentUploadSchema.shape.name.parse(metadata.name);
+            if (metadata.id !== id)
+                throw new Error('invalid_attachment');
+            const path = join(directory, metadata.name);
+            const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const stat = await handle.stat();
+                if (!stat.isFile() || stat.size > WORKSPACE_ATTACHMENT_MAX_BYTES)
+                    throw new Error('invalid_attachment');
+                const bytes = await handle.readFile();
+                return { ...metadata, size: bytes.length, mimeType: imageMime(bytes), path };
+            }
+            finally {
+                await handle.close();
+            }
+        }));
+    }
+    catch {
+        throw new NativePreparationError('attachment_unavailable');
+    }
+}

package/dist/workspace-runtime/workspaces/cli-credentials.js

@@ -0,0 +1,114 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+const responseSchema = z.object({
+    token: z.string().min(1),
+    apiUrl: z.string().url(),
+    expiresAt: z.string().datetime(),
+    claims: z.object({
+        kind: z.literal('cloud-runtime-cli'),
+        environment: z.string(),
+        userId: z.string(),
+        runtimeId: z.string(),
+        generation: z.number().int(),
+        runtimeEpoch: z.number().int(),
+    }),
+});
+const entries = new WeakMap();
+/** The file is outside every checkout, shared by all workspaces owned by this sandbox's user. */
+export async function ensureCliCredentials(state) {
+    let entry = entries.get(state);
+    if (!entry) {
+        entry = { closed: false, expiresAt: 0, epoch: -1 };
+        entries.set(state, entry);
+    }
+    if (entry.closed)
+        throw new Error('cli_credentials_unavailable');
+    if (entry.epoch === state.runtimeEpoch && entry.expiresAt > Date.now() + 60_000)
+        return;
+    if (!entry.pending)
+        entry.pending = renew(state, entry).finally(() => {
+            entry.pending = undefined;
+        });
+    await entry.pending;
+}
+async function renew(state, entry) {
+    const config = state.config;
+    const epoch = state.runtimeEpoch;
+    const endpoint = new URL('/runtime/internal/cli-credentials', config.callbackUrl);
+    if (endpoint.protocol !== 'https:' &&
+        !(endpoint.protocol === 'http:' &&
+            ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
+        throw new Error('cli_callback_insecure');
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            redirect: 'error',
+            signal: AbortSignal.timeout(10_000),
+            headers: {
+                authorization: `Bearer ${config.controlToken}`,
+                'content-type': 'application/json',
+                'playcraft-env': config.environment,
+            },
+            body: JSON.stringify({
+                runtimeId: config.runtimeId,
+                generation: config.generation,
+                runtimeEpoch: epoch,
+            }),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error('cli_credentials_unavailable');
+        }
+        const credential = responseSchema.parse(await response.json());
+        const claims = credential.claims;
+        if (entry.closed ||
+            state.journal.destroyed() ||
+            epoch !== state.runtimeEpoch ||
+            claims.environment !== config.environment ||
+            claims.userId !== config.userId ||
+            claims.runtimeId !== config.runtimeId ||
+            claims.generation !== config.generation ||
+            claims.runtimeEpoch !== epoch ||
+            Date.parse(credential.expiresAt) <= Date.now() + 60_000)
+            throw new Error('cli_credential_scope_mismatch');
+        await mkdir(config.workspaceRoot, { recursive: true });
+        const temporary = join(config.workspaceRoot, `.playcraft-credential-${randomUUID()}.tmp`);
+        try {
+            await writeFile(temporary, JSON.stringify({
+                apiUrl: credential.apiUrl,
+                token: credential.token,
+                env: config.environment,
+                userId: config.userId,
+                expiresAt: credential.expiresAt,
+            }), { flag: 'wx', mode: 0o644 });
+            await rename(temporary, join(config.workspaceRoot, '.playcraft.json'));
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        entry.expiresAt = Date.parse(credential.expiresAt);
+        entry.epoch = epoch;
+    }
+    finally {
+        if (!entry.closed && !state.journal.destroyed()) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            const wait = entry.expiresAt > Date.now() + 60_000 ? entry.expiresAt - Date.now() - 59_000 : 30_000;
+            entry.timer = setTimeout(() => void ensureCliCredentials(state).catch(() => undefined), wait);
+            entry.timer.unref();
+        }
+    }
+}
+export async function closeCliCredentials(state) {
+    const entry = entries.get(state);
+    if (entry) {
+        entry.closed = true;
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        await entry.pending?.catch(() => undefined);
+    }
+    if (entry)
+        await rm(join(state.config.workspaceRoot, '.playcraft.json'), { force: true });
+}

package/dist/workspace-runtime/workspaces/empty-template.js

@@ -0,0 +1,32 @@
+import { cp, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { resolveCliPackageRoot } from '../../scaffold/compose.js';
+import { syncLocalProjectSkills } from '../../project-skills/local-store.js';
+export const EMPTY_WORKSPACE_DEFAULT_SKILLS = [
+    'playcraft-skill-recommender',
+    'playcraft-image-generation',
+    'playcraft-audio-generation',
+    'playcraft-image-processing',
+    'playcraft-build-optimizer',
+];
+/** Only called in a new, unpublished staging directory; existing workspaces are never scaffolded. */
+export async function scaffoldEmptyWorkspace(root, skillCache) {
+    const cliRoot = resolveCliPackageRoot();
+    const template = join(cliRoot, 'project-templates', 'empty');
+    for (const [source, target] of [
+        ['gitignore', '.gitignore'],
+        ['AGENTS.md', 'AGENTS.md'],
+    ]) {
+        await cp(join(template, source), join(root, target), { force: false, errorOnExist: true });
+    }
+    const skills = join(root, '.agents', 'skills');
+    await mkdir(skills, { recursive: true });
+    for (const name of EMPTY_WORKSPACE_DEFAULT_SKILLS) {
+        await cp(join(cliRoot, 'project-template', '.claude', 'skills', name), join(skills, name), {
+            recursive: true,
+            force: false,
+            errorOnExist: true,
+        });
+    }
+    await syncLocalProjectSkills(root, skillCache);
+}

package/dist/workspace-runtime/workspaces/file-snapshot.js

@@ -1,6 +1,6 @@
 import { chmod, lstat, mkdir, readdir, readFile, readlink, realpath, rm, symlink, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { fileSnapshotDigest, fileSnapshotManifestKey, fileSnapshotContentKey, nativeTranscriptKey, fileSnapshotManifestSchema, hashSnapshotBytes, isDisposableBackupPath, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { fileSnapshotDigest, fileSnapshotManifestKey, fileSnapshotContentKey, nativeTranscriptKey, fileSnapshotManifestSchema, hashSnapshotBytes, isDisposableBackupPath, isWorkspaceAttachmentPath, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { UNPUSHED_BUNDLE, addBundleObjects, repositoryResolves } from './git.js';
 const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
 /** Build output, caches and scratch folders, at any depth: regenerated, so not kept in storage. */
@@ -46,6 +46,8 @@ const UNSTORED_RUN_OUTPUT = [
  * does not remove them.
  */
 export function keptInStorage(path) {
+    if (isWorkspaceAttachmentPath(path))
+        return true;
     if (isDisposableBackupPath(path))
         return false;
     if (path.startsWith('.git/'))
@@ -161,7 +163,7 @@ export async function materializeRemoteSnapshot(root, entries) {
             await rm(target, { force: true });
             continue;
         }
-        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+        await mkdir(dirname(target), { recursive: true, mode: isWorkspaceAttachmentPath(entry.path) ? 0o755 : 0o700 });
         if (entry.kind === 'symlink') {
             if (!entry.target)
                 throw new Error('snapshot_mismatch');

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

@@ -1,6 +1,6 @@
 import { mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { hashWorkspaceFileContent, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { hashWorkspaceFileContent, hashSnapshotBytes, isWorkspaceAttachmentPath, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
 const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
 export class InvalidWorkspacePathError extends Error {
     code = 'invalid_workspace_path';
@@ -71,11 +71,11 @@ export async function snapshotWorkspaceFiles(root, snapshotDir, revisions) {
     await rm(snapshotDir, { recursive: true, force: true });
     const records = [];
     for (const file of listed.files) {
-        const content = await readWorkspaceFile(root, file.path, revisions);
+        const content = await readFile(await resolveWorkspaceFile(root, file.path));
         const target = join(snapshotDir, ...file.path.split('/'));
         await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-        await writeFile(target, content.content, { mode: 0o600 });
-        records.push({ path: file.path, contentHash: file.contentHash, revision: file.revision });
+        await writeFile(target, content, { mode: 0o600 });
+        records.push({ path: file.path, contentHash: hashSnapshotBytes(content), revision: file.revision });
     }
     return records;
 }
@@ -83,16 +83,17 @@ export async function restoreWorkspaceFiles(root, snapshotDir, files) {
     const rootReal = await ensureWorkspaceRoot(root);
     const keep = new Set(files.map((item) => item.path));
     for (const relativePath of await walkWorkspaceFiles(rootReal, rootReal)) {
-        if (!keep.has(relativePath)) {
+        if (!keep.has(relativePath) && !isWorkspaceAttachmentPath(relativePath)) {
             await rm(join(rootReal, ...relativePath.split('/')), { force: true });
         }
     }
     const next = {};
     for (const file of files) {
         const source = join(snapshotDir, ...file.path.split('/'));
-        const content = await readFile(source, 'utf8');
-        await writeWorkspaceFile(root, file.path, content);
-        next[file.path] = { revision: file.revision, contentHash: hashWorkspaceFileContent(content) };
+        const content = await readFile(source);
+        const target = await resolveWorkspaceFile(root, file.path);
+        await writeFile(target, content, { mode: isWorkspaceAttachmentPath(file.path) ? 0o644 : 0o600 });
+        next[file.path] = { revision: file.revision, contentHash: hashSnapshotBytes(content) };
     }
     return next;
 }

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

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { excludeFromGit } from './dependencies.js';
 import { lstat, mkdir, readFile, realpath, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
@@ -346,6 +347,7 @@ export async function ensureWorkspaceGit(root) {
         await git(rootReal, ['config', 'user.email', 'workspace@playcraft.local']);
     }
     await assertWorkspaceGitRoot(rootReal);
+    await excludeFromGit(rootReal, '/.tmp/user_uploads/');
     return rootReal;
 }
 async function gitMarkerExists(rootReal) {

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

@@ -4,6 +4,7 @@ import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs
 import { join } from 'node:path';
 import { isLocalWorkspaceGitAuthMode, isLocalWorkspaceGitEnvironment, matchWorkspaceGitGatewayCloneUrl, workspacePreparationSchema, workspaceRegistrationSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { WorkspaceContextError } from './context-error.js';
+import { scaffoldEmptyWorkspace } from './empty-template.js';
 /** The caller holds the Workspace lock. Only an absent, never-published directory may be prepared. */
 export async function prepareWorkspaceCheckout(state, binding, input, leaseFence) {
     const preparation = workspacePreparationSchema.safeParse(input);
@@ -82,22 +83,31 @@ export async function prepareWorkspaceCheckout(state, binding, input, leaseFence
         try {
             if (standalone) {
                 await runGit(['init', '--initial-branch=main', staging], env, deadline);
+                await scaffoldEmptyWorkspace(staging, join(state.config.stateDir, 'skill-artifacts'));
             }
             else {
+                const fork = binding.pendingFork;
+                const cloneBranch = fork?.sourceBranchName ?? binding.branchName;
                 await runGit(['check-ref-format', '--branch', binding.branchName], env, deadline);
+                await runGit(['check-ref-format', '--branch', cloneBranch], env, deadline);
                 await runGit([
                     'clone',
                     '--no-checkout',
                     '--single-branch',
                     '--branch',
-                    binding.branchName,
+                    cloneBranch,
                     '--',
                     binding.repositoryUrl,
                     staging,
                 ], env, deadline);
                 // Checkout never receives the temporary credential and never invokes repository hooks or global filters.
                 clearCloneSecrets(env);
-                await runGit(['-C', staging, 'checkout', '--force', binding.branchName], env, deadline);
+                if (fork) {
+                    await runGit(['-C', staging, 'checkout', '-b', binding.branchName, fork.sourceCommit], env, deadline);
+                }
+                else {
+                    await runGit(['-C', staging, 'checkout', '--force', binding.branchName], env, deadline);
+                }
             }
             assertCurrent();
             receipt.status = 'ready';

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

@@ -6,6 +6,8 @@ import { isLocalWorkspaceGitAuthMode, workspaceRegistrationSchema, } from '@play
 import { prepareWorkspaceCheckout } from './prepare.js';
 import { WorkspaceContextError } from './context-error.js';
 import { scheduleDependencyInstall } from './dependencies.js';
+import { ensureWorkspaceSkills, readWorkspaceSkills } from './skills.js';
+import { loadWorkspaceSkillArtifact } from './skill-artifact-loader.js';
 export { WorkspaceContextError } from './context-error.js';
 const exec = promisify(execFile);
 export function revisionScope(state, workspaceId) {
@@ -121,7 +123,17 @@ export async function registerWorkspace(state, input, leaseFence, preparation) {
                 throw new WorkspaceContextError('workspace_git_gateway_unavailable');
             }
         }
+        try {
+            await ensureWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'));
+        }
+        catch {
+            throw new WorkspaceContextError('workspace_skills_unavailable');
+        }
         await state.journal.putWorkspace(binding);
+        try {
+            await readWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'), entry => loadWorkspaceSkillArtifact(state, binding.workspaceId, entry));
+        }
+        catch { /* Skills reads and native turns diagnose missing artifacts; files and source repair remain available. */ }
         // Runs in the background; every registration rechecks it, so reopening retries a failed install.
         void scheduleDependencyInstall(state, binding.workspaceId, root);
         return binding;

package/dist/workspace-runtime/workspaces/skill-artifact-loader.js

@@ -0,0 +1,47 @@
+import { createHash } from 'node:crypto';
+import { workspaceRoot } from './registry.js';
+const MAX_ARTIFACT_BYTES = 80 * 1024 * 1024;
+/** Requests an exact locked artifact using control identity; no storage credentials reach Codex. */
+export async function loadWorkspaceSkillArtifact(state, workspaceId, entry) {
+    await workspaceRoot(state, workspaceId);
+    const epoch = state.runtimeEpoch;
+    if (state.journal.destroyed())
+        throw new Error('workspace_skills_unavailable');
+    const endpoint = new URL('/runtime/internal/skill-artifacts', state.config.callbackUrl);
+    if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
+        throw new Error('workspace_skills_callback_insecure');
+    const response = await fetch(endpoint, {
+        method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
+        headers: { authorization: `Bearer ${state.config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': state.config.environment },
+        body: JSON.stringify({ runtimeId: state.config.runtimeId, generation: state.config.generation,
+            runtimeEpoch: epoch, workspaceId, entryKey: entry.entryKey, revision: entry.revision }),
+    });
+    if (!response.ok || !response.body)
+        throw new Error('workspace_skills_artifact_unavailable');
+    const reader = response.body.getReader(), chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            total += chunk.value.byteLength;
+            if (total > Math.ceil(MAX_ARTIFACT_BYTES * 4 / 3) + 4096)
+                throw new Error('workspace_skills_artifact_too_large');
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+    const result = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (typeof result.content !== 'string' || result.artifactHash !== entry.revision.artifactHash
+        || result.content.length > Math.ceil(MAX_ARTIFACT_BYTES * 4 / 3) || result.content.length % 4 !== 0 || /[^A-Za-z0-9+/=]/.test(result.content))
+        throw new Error('workspace_skills_digest_mismatch');
+    const archive = Buffer.from(result.content, 'base64');
+    if (archive.byteLength > MAX_ARTIFACT_BYTES || archive.toString('base64') !== result.content || createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    if (state.journal.destroyed() || epoch !== state.runtimeEpoch)
+        throw new Error('workspace_skills_unavailable');
+    return archive;
+}