@playcraft/cli 0.1.23 → 0.1.25

package/dist/project-skills/builtin-import.js

@@ -0,0 +1,225 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { canonicalProjectSkillsJson, declarationDigest, dependencyDigest, extractBundleArchive, readProjectSkillSource, readProjectSkillsLockFile, validateProjectSkillsSnapshot, PROJECT_SKILLS_DECLARATION_PATH, PROJECT_SKILLS_LOCK_PATH, } from '@playcraft/common/project-skills';
+import { LEGACY_VIDEO_SOURCE_HASHES } from '@playcraft/common/cloud-workspace/runtime';
+import { projectSkillsCache } from './local-store.js';
+export const IMPORTABLE_BUILTIN_SKILLS = ['playcraft-video-understanding', 'playcraft-replica-validation'];
+export const platformSkillRef = (name) => `remix/${name}`;
+const hash = (value) => createHash('sha256').update(canonicalProjectSkillsJson(value)).digest('hex');
+async function safeDirectory(root, path) {
+    let current = root;
+    for (const part of path.split('/')) {
+        current = join(current, part);
+        await mkdir(current, { mode: 0o755 }).catch(error => { if (error.code !== 'EEXIST')
+            throw error; });
+        const stat = await lstat(current);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error('workspace_skills_invalid');
+    }
+    return current;
+}
+/** Selects published platform revisions once; neither directory contents nor names authorize a replacement. */
+export async function selectPlatformSkillSnapshot(names, access) {
+    if (!names.length || new Set(names).size !== names.length
+        || names.some(name => !IMPORTABLE_BUILTIN_SKILLS.includes(name)))
+        throw new Error('workspace_skills_builtin_unknown');
+    if (!access)
+        throw new Error('workspace_skills_platform_required');
+    const requested = names.map(platformSkillRef);
+    const response = await access.resolve(requested);
+    const snapshot = validateProjectSkillsSnapshot(response?.declaration, response?.lock);
+    if (snapshot.declaration.entries.length !== names.length || snapshot.lock.entries.length !== names.length)
+        throw new Error('workspace_skills_invalid');
+    for (const name of names) {
+        const entry = snapshot.declaration.entries.find(item => item.entryKey === name);
+        const locked = snapshot.lock.entries.find(item => item.entryKey === name);
+        if (!entry || !locked || entry.source.kind !== 'registry' || entry.source.skillRef !== platformSkillRef(name)
+            || entry.surface !== 'sandbox-agent' || !entry.enabled || locked.revision.kind !== 'release'
+            || locked.dependencies.length !== 0 || locked.dependencyLockHash !== dependencyDigest([], []))
+            throw new Error('workspace_skills_invalid');
+    }
+    const artifacts = await Promise.all(snapshot.lock.entries.map(async (entry) => {
+        const archive = await access.loadArtifact(entry);
+        if (archive.length > 80 * 1024 * 1024 || createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
+            throw new Error('workspace_skills_digest_mismatch');
+        const extracted = extractBundleArchive(archive);
+        if (extracted.issues.length || !extracted.files.some(file => file.path === 'SKILL.md'))
+            throw new Error('workspace_skills_invalid_bundle');
+        return { artifactHash: entry.revision.artifactHash, archive };
+    }));
+    return { ...snapshot, artifacts };
+}
+async function commitSnapshot(directory, snapshot, originalDeclaration, staged) {
+    const declarationPath = join(directory, PROJECT_SKILLS_DECLARATION_PATH);
+    const pending = [];
+    for (const [path, value] of [[PROJECT_SKILLS_DECLARATION_PATH, snapshot.declaration], [PROJECT_SKILLS_LOCK_PATH, snapshot.lock]]) {
+        const temporary = `${join(directory, path)}.${randomUUID()}.tmp`;
+        staged.push(temporary);
+        await writeFile(temporary, `${canonicalProjectSkillsJson(value)}\n`, { flag: 'wx', mode: 0o644 });
+        pending.push(temporary);
+    }
+    await rename(pending[0], declarationPath);
+    try {
+        await rename(pending[1], join(directory, PROJECT_SKILLS_LOCK_PATH));
+    }
+    catch (error) {
+        // The old lock still exists. Restore its exact declaration before releasing the writer lease.
+        const restore = `${declarationPath}.${randomUUID()}.tmp`;
+        staged.push(restore);
+        await writeFile(restore, originalDeclaration, { flag: 'wx', mode: 0o644 });
+        await rename(restore, declarationPath);
+        throw error;
+    }
+}
+async function cacheArtifacts(cache, selected) {
+    await mkdir(cache, { recursive: true, mode: 0o700 });
+    for (const artifact of selected.artifacts) {
+        const path = join(cache, `${artifact.artifactHash}.tar.gz`);
+        try {
+            await writeFile(path, artifact.archive, { flag: 'wx', mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST' || !(await readFile(path)).equals(artifact.archive))
+                throw error;
+        }
+    }
+}
+/** Explicit imports keep prior locks and unsynced repository sources byte-for-byte. */
+export async function importBuiltinProjectSkills(directory, options, cache = projectSkillsCache(), access, selected, enabled = false) {
+    if (!options.names.length || new Set(options.names).size !== options.names.length
+        || options.names.some(name => !IMPORTABLE_BUILTIN_SKILLS.includes(name)))
+        throw new Error('workspace_skills_builtin_unknown');
+    const management = await safeDirectory(directory, '.playcraft');
+    const lease = join(management, 'skills-write.lock');
+    await writeFile(lease, `${process.pid}\n`, { flag: 'wx', mode: 0o600 });
+    const staged = [];
+    try {
+        const declarationPath = join(directory, PROJECT_SKILLS_DECLARATION_PATH);
+        const declarationStat = await lstat(declarationPath);
+        if (!declarationStat.isFile() || declarationStat.isSymbolicLink() || declarationStat.size > 1024 * 1024)
+            throw new Error('workspace_skills_invalid');
+        const originalDeclaration = await readFile(declarationPath);
+        const previous = validateProjectSkillsSnapshot(originalDeclaration.toString('utf8'), await readProjectSkillsLockFile(directory));
+        if (options.expectedDeclarationHash !== previous.lock.declarationHash || options.expectedLockHash !== hash(previous.lock))
+            throw new Error('skills_revision_conflict');
+        const next = structuredClone(previous);
+        const unchanged = [], missing = [];
+        for (const name of options.names) {
+            const existing = previous.declaration.entries.find(entry => entry.source.kind === 'registry' && entry.source.skillRef === platformSkillRef(name));
+            if (existing) {
+                unchanged.push(existing.entryKey);
+                continue;
+            }
+            if (previous.declaration.entries.some(entry => entry.entryKey === name || entry.source.kind === 'repository' && basename(entry.source.root) === name))
+                throw new Error('workspace_skills_builtin_conflict');
+            for (const sourceRoot of ['.agents/skills', '.claude/skills', '.opencode/skills', '.opencode/skill']) {
+                if (await lstat(join(directory, sourceRoot, name)).then(() => true, error => { if (error.code === 'ENOENT')
+                    return false; throw error; }))
+                    throw new Error('workspace_skills_builtin_conflict');
+            }
+            missing.push(name);
+        }
+        const imported = [];
+        if (missing.length) {
+            const resolved = selected ?? await selectPlatformSkillSnapshot(missing, access);
+            await cacheArtifacts(cache, resolved);
+            for (const name of missing) {
+                const entry = resolved.declaration.entries.find(item => item.entryKey === name);
+                const locked = resolved.lock.entries.find(item => item.entryKey === name);
+                if (!entry || !locked)
+                    throw new Error('workspace_skills_invalid');
+                next.declaration.entries.push({ ...entry, enabled });
+                next.lock.entries.push(locked);
+                imported.push(name);
+            }
+            next.lock.declarationHash = declarationDigest(next.declaration);
+            validateProjectSkillsSnapshot(next.declaration, next.lock);
+            await commitSnapshot(directory, next, originalDeclaration, staged);
+        }
+        return { ...next, imported, unchanged, lockHash: hash(next.lock) };
+    }
+    finally {
+        for (const path of staged)
+            await rm(path, { force: true });
+        await rm(lease, { force: true });
+    }
+}
+/** Only original bundled sources qualify; changed or forked skills require a separate explicit user decision. */
+export async function migrateVideoProjectSkills(directory, options, cache, access) {
+    const management = await safeDirectory(directory, '.playcraft');
+    const lease = join(management, 'skills-write.lock');
+    await writeFile(lease, `${process.pid}\n`, { flag: 'wx', mode: 0o600 });
+    const moved = [];
+    const staged = [];
+    let committed = false;
+    try {
+        const declarationPath = join(directory, PROJECT_SKILLS_DECLARATION_PATH);
+        const declarationStat = await lstat(declarationPath);
+        if (!declarationStat.isFile() || declarationStat.isSymbolicLink() || declarationStat.size > 1024 * 1024)
+            throw new Error('workspace_skills_invalid');
+        const originalDeclaration = await readFile(declarationPath);
+        const previous = validateProjectSkillsSnapshot(originalDeclaration.toString('utf8'), await readProjectSkillsLockFile(directory));
+        const oldLockHash = hash(previous.lock);
+        if (options.expectedDeclarationHash !== previous.lock.declarationHash || options.expectedLockHash !== oldLockHash)
+            throw new Error('skills_revision_conflict');
+        if (!options.entryKeys.length || options.entryKeys.length > 2 || new Set(options.entryKeys).size !== options.entryKeys.length)
+            throw new Error('workspace_skills_builtin_unknown');
+        const replacements = [];
+        for (const key of options.entryKeys) {
+            const entry = previous.declaration.entries.find(item => item.entryKey === key);
+            const locked = previous.lock.entries.find(item => item.entryKey === key);
+            if (!entry || !locked || entry.source.kind !== 'repository' || locked.revision.kind !== 'source'
+                || entry.surface !== 'sandbox-agent' || entry.projectFiles?.length || locked.dependencies.length
+                || previous.lock.entries.some(item => item.entryKey !== key && item.dependencies.includes(key)))
+                throw new Error('workspace_skills_builtin_conflict');
+            const name = basename(entry.source.root);
+            const known = LEGACY_VIDEO_SOURCE_HASHES[name];
+            if (!known || locked.sourceTreeHash !== known || (await readProjectSkillSource(directory, entry)).sourceTreeHash !== known
+                || previous.declaration.entries.some(item => item.entryKey !== key && (item.entryKey === name || item.source.kind === 'registry' && item.source.skillRef === platformSkillRef(name))))
+                throw new Error('workspace_skills_builtin_conflict');
+            replacements.push({ entry, name });
+        }
+        const selected = await selectPlatformSkillSnapshot(replacements.map(item => item.name), access);
+        await cacheArtifacts(cache, selected);
+        const next = structuredClone(previous);
+        for (const { entry, name } of replacements) {
+            const replacement = selected.declaration.entries.find(item => item.entryKey === name);
+            const locked = selected.lock.entries.find(item => item.entryKey === name);
+            next.declaration.entries[next.declaration.entries.findIndex(item => item.entryKey === entry.entryKey)] = { ...replacement, entryKey: entry.entryKey, enabled: entry.enabled };
+            next.lock.entries[next.lock.entries.findIndex(item => item.entryKey === entry.entryKey)] = { ...locked, entryKey: entry.entryKey };
+        }
+        for (const locked of next.lock.entries)
+            locked.dependencyLockHash = dependencyDigest(next.lock.entries, locked.dependencies);
+        next.lock.declarationHash = declarationDigest(next.declaration);
+        validateProjectSkillsSnapshot(next.declaration, next.lock);
+        const history = await safeDirectory(directory, `.playcraft/skill-migrations/${oldLockHash}`);
+        const receipt = { schemaVersion: 'playcraft.skill-migration.v1', previous, next, entryKeys: options.entryKeys };
+        const historyFile = join(history, 'migration.json');
+        try {
+            await writeFile(historyFile, `${canonicalProjectSkillsJson(receipt)}\n`, { flag: 'wx', mode: 0o644 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST' || await readFile(historyFile, 'utf8') !== `${canonicalProjectSkillsJson(receipt)}\n`)
+                throw error;
+        }
+        for (const { entry } of replacements) {
+            if (entry.source.kind !== 'repository')
+                throw new Error('workspace_skills_invalid');
+            const from = join(directory, entry.source.root), to = join(history, entry.entryKey);
+            await rename(from, to);
+            moved.push({ from, to });
+        }
+        await commitSnapshot(directory, next, originalDeclaration, staged);
+        committed = true;
+        return { ...next, migrated: options.entryKeys, history: `.playcraft/skill-migrations/${oldLockHash}/migration.json`, lockHash: hash(next.lock) };
+    }
+    finally {
+        if (!committed)
+            for (const item of moved.reverse())
+                await rename(item.to, item.from).catch(() => undefined);
+        for (const path of staged)
+            await rm(path, { force: true });
+        await rm(lease, { force: true });
+    }
+}

package/dist/project-skills/commands.js

@@ -7,6 +7,7 @@ import { syncLocalProjectSkills, enableLocalProjectSkill, installFrozenProjectSk
 import { runLocalProjectSkills, localProjectSkillUsage } from './local-run.js';
 import { projectSkillsMessage as t } from './messages.js';
 import { reconcileLocalProjectSkills } from './reconcile.js';
+import { importBuiltinProjectSkills } from './builtin-import.js';
 export async function inspectLocalProjectSkills(directory) {
     const inventory = await inspectProjectSkills(directory);
     // Report metadata only; never print complete skill bytes or project test data.
@@ -21,7 +22,7 @@ export function registerProjectSkillsCommands(skills) {
             process.stdout.write(`${JSON.stringify(await action(), null, 2)}\n`);
         }
         catch (error) {
-            process.stderr.write(`${t('failed')}: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.stderr.write(`${t('failed')}: ${error instanceof Error && error.message === 'workspace_skills_platform_required' ? t('platformRequired') : error instanceof Error ? error.message : String(error)}\n`);
             process.exitCode = 1;
         }
     };
@@ -36,6 +37,10 @@ export function registerProjectSkillsCommands(skills) {
         .action((options) => output(() => localProjectSkillUsage(resolve(options.dir))));
     project.command('sync').description(t('sync')).option('--dir <path>', t('directory'), '.')
         .action((options) => output(() => syncLocalProjectSkills(resolve(options.dir))));
+    project.command('import-builtins <names...>').description(t('importBuiltins')).option('--dir <path>', t('directory'), '.')
+        .requiredOption('--expected-declaration-hash <hash>', t('expectedDeclarationHash'))
+        .requiredOption('--expected-lock-hash <hash>', t('expectedLockHash'))
+        .action((names, options) => output(() => importBuiltinProjectSkills(resolve(options.dir), { ...options, names })));
     project.command('reconcile').description(t('reconcile')).option('--dir <path>', t('directory'), '.')
         .action((options) => output(() => reconcileLocalProjectSkills(resolve(options.dir), { write: true })));
     project.command('install').description(t('install')).requiredOption('--frozen', t('frozen')).option('--dir <path>', t('directory'), '.')

package/dist/project-skills/local-store.js

@@ -3,7 +3,7 @@ import { mkdir, readFile, rename, rm, writeFile, lstat } from 'node:fs/promises'
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { projectSkillsMessage as t } from './messages.js';
-import { buildLocalProjectSkillsSnapshot, canonicalProjectSkillsJson, extractBundleArchive, createCanonicalBundleArchive, readProjectSkillSource, sourceTreeDigest, readProjectSkillsLockFile, inspectProjectSkills, setProjectSkillEnabled, validateProjectSkillsSnapshot, effectiveProjectSkills, PROJECT_SKILLS_DECLARATION_PATH, PROJECT_SKILLS_LOCK_PATH, } from '@playcraft/common/project-skills';
+import { buildLocalProjectSkillsSnapshot, canonicalProjectSkillsJson, extractBundleArchive, createCanonicalBundleArchive, readProjectSkillSource, sourceTreeDigest, readProjectSkillsLockFile, inspectProjectSkills, setProjectSkillEnabled, validateProjectSkillsSnapshot, declarationDigest, effectiveProjectSkills, PROJECT_SKILLS_DECLARATION_PATH, PROJECT_SKILLS_LOCK_PATH, } from '@playcraft/common/project-skills';
 export const projectSkillsCache = () => process.env.PLAYCRAFT_SKILLS_CACHE_DIR
     ? resolve(process.env.PLAYCRAFT_SKILLS_CACHE_DIR) : join(homedir(), '.playcraft', 'skill-artifacts');
 export async function readLocalProjectSkillSnapshot(directory) {
@@ -35,6 +35,78 @@ async function writeSnapshot(directory, snapshot) {
         await rename(temporary, target);
     }
 }
+/** Initializes an unmanaged checkout with one complete source and release snapshot under the existing writer lease. */
+export async function initializeLocalProjectSkills(directory, cache, options) {
+    return change(directory, async () => {
+        if (await readProjectSkillsLockFile(directory) !== null)
+            throw new Error('skills_revision_conflict');
+        const declarationPath = join(directory, PROJECT_SKILLS_DECLARATION_PATH);
+        let originalDeclaration;
+        try {
+            const stat = await lstat(declarationPath);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+                throw new Error('workspace_skills_invalid');
+            originalDeclaration = await readFile(declarationPath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        let configurationWriteStarted = false;
+        try {
+            await options.prepareSources?.();
+            const snapshot = buildLocalProjectSkillsSnapshot(await inspectProjectSkills(directory));
+            for (const entry of snapshot.declaration.entries)
+                if (entry.source.kind === 'repository' && options.enabledRoots.has(entry.source.root))
+                    entry.enabled = true;
+            if (options.platform) {
+                const platform = validateProjectSkillsSnapshot(options.platform.declaration, options.platform.lock);
+                if (platform.declaration.entries.some(entry => entry.source.kind !== 'registry'))
+                    throw new Error('workspace_skills_invalid');
+                snapshot.declaration.entries.push(...platform.declaration.entries);
+                snapshot.lock.entries.push(...platform.lock.entries);
+            }
+            snapshot.lock.declarationHash = declarationDigest(snapshot.declaration);
+            validateProjectSkillsSnapshot(snapshot.declaration, snapshot.lock);
+            await mkdir(cache, { recursive: true, mode: 0o700 });
+            // Every artifact is ready before the first configuration write; an input/output failure cannot leave a valid subset lock.
+            for (const artifact of [...snapshot.artifacts, ...(options.platform?.artifacts ?? [])]) {
+                if (createHash('sha256').update(artifact.archive).digest('hex') !== artifact.artifactHash)
+                    throw new Error('workspace_skills_digest_mismatch');
+                const target = join(cache, `${artifact.artifactHash}.tar.gz`), temporary = `${target}.${randomUUID()}.tmp`;
+                try {
+                    await writeFile(temporary, artifact.archive, { flag: 'wx', mode: 0o600 });
+                    await rename(temporary, target);
+                }
+                finally {
+                    await rm(temporary, { force: true });
+                }
+            }
+            configurationWriteStarted = true;
+            await writeSnapshot(directory, snapshot);
+            return { declaration: snapshot.declaration, lock: snapshot.lock };
+        }
+        catch (error) {
+            if (configurationWriteStarted) {
+                if (originalDeclaration === undefined)
+                    await rm(declarationPath, { force: true });
+                else {
+                    const temporary = `${declarationPath}.${randomUUID()}.tmp`;
+                    try {
+                        await writeFile(temporary, originalDeclaration, { flag: 'wx', mode: 0o644 });
+                        await rename(temporary, declarationPath);
+                    }
+                    finally {
+                        await rm(temporary, { force: true });
+                    }
+                }
+                await rm(join(directory, PROJECT_SKILLS_LOCK_PATH), { force: true });
+            }
+            await options.rollbackSources?.();
+            throw error;
+        }
+    });
+}
 export async function syncLocalProjectSkills(directory, cache = projectSkillsCache()) {
     return change(directory, async () => {
         let previous;

package/dist/project-skills/messages.js

@@ -1,5 +1,9 @@
 const messages = {
     en: {
+        importBuiltins: 'Import published platform skills in Cloud Workspace; preserve exact existing revisions',
+        platformRequired: 'Use Cloud Workspace’s Skills panel to import published platform skills. Local template import is unavailable.',
+        expectedDeclarationHash: 'Expected declaration digest from the current skill lock',
+        expectedLockHash: 'Expected digest of the canonical current skill lock',
         reconcile: 'Register the pushed commit and adopt verified platform skill identities',
         reconcileChanged: 'The branch, source bytes, or settings changed. Sync, commit and push the current project before reconciling.',
         reconcilePending: 'Indexing continues on the server. Retry reconcile later. Operation:',
@@ -33,6 +37,10 @@ const messages = {
         changed: 'Source files have changed since the saved revision',
     },
     zh: {
+        importBuiltins: '在云工作区导入已发布平台技能，保留已有精确修订',
+        platformRequired: '请在云工作区的技能面板导入已发布平台技能；本地模板导入已停用。',
+        expectedDeclarationHash: '当前技能锁中的声明摘要',
+        expectedLockHash: '当前技能锁规范化内容的摘要',
         reconcile: '登记已推送的提交，并采用平台核验后的技能身份',
         reconcileChanged: '分支、源文件或配置发生变化，请同步、提交并推送当前项目后再对账。',
         reconcilePending: '服务端仍在登记，请稍后重新运行 reconcile。操作编号：',

package/dist/recording/messages.js

@@ -0,0 +1,40 @@
+const messages = {
+    en: {
+        topic: 'Record a playable with real browser input', record: 'Record a scenario and fresh-context interaction controls',
+        url: 'Running playable URL on this workspace loopback interface', scenario: 'Validated scenario JSON file',
+        out: 'Empty artifact directory', browser: 'Absolute Chromium executable path', timeout: 'Maximum recording time in seconds',
+        invalidArguments: 'Invalid recording arguments or scenario.', invalidUrl: 'The playable URL must use HTTP on the workspace loopback interface without credentials.',
+        browserUnavailable: 'Chromium or the Playwright video encoder is unavailable. Check the workspace image.',
+        navigationFailed: 'The playable did not navigate successfully or left its authorized origin.',
+        projectChanged: 'Project inputs changed while recording. Record the current project again.',
+        projectUnavailable: 'The project input digest could not be completed safely.',
+        recordingFailed: 'Recording failed. Inspect the partial recording and runtime logs.',
+        outputConflict: 'The recording output directory must be empty.',
+        recording: 'Recording the playable and interaction controls',
+        timedOut: 'Recording timed out. Partial evidence was preserved.', interrupted: 'Recording was interrupted. Partial evidence was preserved.',
+    },
+    zh: {
+        topic: '使用真实浏览器输入录制可玩作品', record: '录制操作场景和使用独立空上下文的交互对照',
+        url: '当前工作区回环地址上的作品服务', scenario: '经过验证的操作场景文件', out: '空的证据输出目录',
+        browser: 'Chromium 可执行文件的绝对路径', timeout: '录制最长秒数', invalidArguments: '录制参数或场景无效。',
+        invalidUrl: '作品地址必须使用工作区回环接口的 HTTP 协议，不能包含凭据。',
+        browserUnavailable: 'Chromium 或 Playwright 视频编码器不可用，请检查工作区镜像。',
+        navigationFailed: '作品导航失败，或跳转离开了授权来源。', projectChanged: '录制时工程输入发生了变化，请基于当前工程重新录制。',
+        projectUnavailable: '无法安全完成工程输入摘要。', recordingFailed: '录制失败，请检查保留的局部录像和运行日志。',
+        outputConflict: '录制输出目录必须为空。', recording: '正在录制作品和交互对照',
+        timedOut: '录制超时，已保留局部证据。', interrupted: '录制已中断，已保留局部证据。',
+    },
+};
+export function recordingMessage(key) {
+    const language = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
+    return messages[language.startsWith('zh') ? 'zh' : 'en'][key];
+}
+export class RecordingError extends Error {
+    code;
+    exitCode;
+    constructor(code, exitCode = 4) {
+        super(recordingMessage(code));
+        this.code = code;
+        this.exitCode = exitCode;
+    }
+}

package/dist/recording/project-digest.js

@@ -0,0 +1,85 @@
+import { createHash } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { lstat, open, readdir, realpath } from 'node:fs/promises';
+import { basename, dirname, relative, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
+import { RecordingError } from './messages.js';
+const execute = promisify(execFile);
+const excludedNames = new Set(['.git', 'node_modules', '.DS_Store']);
+const excludedRoots = new Set(['.agents', '.claude', '.codex', '.next', '.vite', '.cache', '.tmp', 'tmp', 'temp', 'dist', 'build', 'coverage', '.playcraft-preview-out', '.playcraft-temp']);
+const excludedInternalPaths = ['.playcraft/video-replication', '.playcraft/skills', '.playcraft/skill-artifacts', '.playcraft/skills.json', '.playcraft/skills.lock.json', '.playcraft/workspace-context.json'];
+const inside = (root, path) => path === root || path.startsWith(`${root}${sep}`);
+const canonicalPath = async (path) => {
+    const absolute = resolve(path);
+    try {
+        return await realpath(absolute);
+    }
+    catch {
+        const parent = dirname(absolute);
+        if (parent === absolute)
+            throw new RecordingError('projectUnavailable', 64);
+        return resolve(await canonicalPath(parent), basename(absolute));
+    }
+};
+/** Hash source, resources, configuration and dependency manifests, including untracked inputs. */
+export async function computeProjectInputDigest(root, excludedOutputDirectories = []) {
+    try {
+        const actualRoot = await realpath(root);
+        const excluded = await Promise.all(excludedOutputDirectories.map(canonicalPath));
+        if (excluded.some(target => inside(target, actualRoot)))
+            throw new RecordingError('projectUnavailable', 64);
+        const hash = createHash('sha256');
+        let fileCount = 0;
+        let totalBytes = 0;
+        const walk = async (directory) => {
+            const entries = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name, 'en'));
+            for (const entry of entries) {
+                if (excludedNames.has(entry.name) || directory === actualRoot && excludedRoots.has(entry.name))
+                    continue;
+                const path = resolve(directory, entry.name);
+                if (excluded.some(target => inside(target, path)))
+                    continue;
+                const rel = relative(actualRoot, path).split(sep).join('/');
+                if (excludedInternalPaths.some(target => rel === target || rel.startsWith(`${target}/`)))
+                    continue;
+                const before = await lstat(path);
+                if (before.isDirectory()) {
+                    await walk(path);
+                    continue;
+                }
+                if (before.isSymbolicLink()) {
+                    const target = await realpath(path);
+                    if (!inside(actualRoot, target) || (await lstat(target)).isDirectory())
+                        throw new RecordingError('projectUnavailable', 64);
+                }
+                else if (!before.isFile())
+                    throw new RecordingError('projectUnavailable', 64);
+                const file = await open(path, 'r');
+                try {
+                    const initial = await file.stat();
+                    totalBytes += initial.size;
+                    if (++fileCount > 50_000 || totalBytes > 1024 * 1024 * 1024)
+                        throw new RecordingError('projectUnavailable', 64);
+                    const content = createHash('sha256');
+                    for await (const bytes of file.createReadStream({ autoClose: false }))
+                        content.update(bytes);
+                    const after = await file.stat();
+                    if (initial.size !== after.size || initial.mtimeMs !== after.mtimeMs || initial.ino !== after.ino)
+                        throw new RecordingError('projectChanged', 64);
+                    hash.update(`${JSON.stringify(rel)}:${initial.mode & 0o777}:${initial.size}:${content.digest('hex')}\n`);
+                }
+                finally {
+                    await file.close();
+                }
+            }
+        };
+        await walk(actualRoot);
+        const gitCommit = await execute('git', ['-C', actualRoot, 'rev-parse', 'HEAD'], { timeout: 5000, maxBuffer: 1024, encoding: 'utf8' }).then(value => value.stdout.trim()).catch(() => null);
+        return { root: actualRoot, gitCommit: gitCommit && /^[a-f0-9]{40,64}$/.test(gitCommit) ? gitCommit : null, sha256: hash.digest('hex'), fileCount };
+    }
+    catch (error) {
+        if (error instanceof RecordingError)
+            throw error;
+        throw new RecordingError('projectUnavailable', 64);
+    }
+}