@playcraft/cli 0.1.66 → 0.1.68

package/dist/workspace-runtime/workspaces/level-editor.js

@@ -0,0 +1,454 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, rename, rm } from 'node:fs/promises';
+import JSON5 from 'json5';
+import { z } from 'zod';
+import { compileLevelEditorDefinition, applyLevelEditorCommand, applyLevelEditorHistory, validateLevelEditorDocuments, levelEditorCanonicalJson, levelEditorSnapshotSchema, levelEditorTransactionRequestSchema, workspaceRelativePathSchema, WORKSPACE_FILE_CONTENT_MAX, LevelEditorError, } from '@playcraft/common/cloud-workspace/runtime';
+import { readParameterAgentFile, parameterInputSnapshot } from './parameter-agent-inputs.js';
+import { resolveWorkspaceFile } from './files.js';
+import { openSharedFile } from './shared-write.js';
+import { parseLevelEditorDocument, serializeLevelEditorDocument } from './level-editor-format.js';
+import { levelEditorExtensionPaths, validateLevelEditorExtensions, } from './level-editor-extensions.js';
+import { recoverPendingLevelEditorTransaction, levelEditorContext, registerLevelEditorContext, transactLevelEditorBatch, } from './level-editor-atomic.js';
+import { readLevelEditorHistory, writeLevelEditorHistory, levelEditorHistoryRequestDigest, assertLevelEditorHistoryScope, } from './level-editor-history-store.js';
+export const levelEditorDigest = (value) => createHash('sha256').update(value).digest('hex');
+const location = z
+    .object({
+    version: z.literal(1),
+    definition: z.string().refine((value) => workspaceRelativePathSchema.safeParse(value).success),
+})
+    .strict();
+const empty = { documents: {}, schemas: {}, revisions: {}, documentHashes: {}, diagnostics: [] };
+function semanticViews(root) {
+    const containers = new Set(['split@1', 'stack@1', 'tabs@1', 'group@1', 'toolbar@1']);
+    const result = [];
+    const visit = (node) => {
+        if (!containers.has(node.component)) {
+            const props = { ...node.props };
+            delete props.titleKey;
+            delete props.descriptionKey;
+            if (node.component === 'inspector@1' && Array.isArray(props.fields)) {
+                props.fields = props.fields
+                    .map((item) => {
+                    if (!item || typeof item !== 'object' || Array.isArray(item))
+                        return item;
+                    const field = { ...item };
+                    delete field.titleKey;
+                    delete field.descriptionKey;
+                    return field;
+                })
+                    .sort((a, b) => levelEditorCanonicalJson(a).localeCompare(levelEditorCanonicalJson(b)));
+            }
+            result.push({
+                id: node.id,
+                component: node.component,
+                bind: node.bind ?? {},
+                actions: node.actions ?? {},
+                props,
+            });
+        }
+        node.children?.forEach(visit);
+    };
+    visit(root);
+    return result.sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function readLevelEditorFile(root, path, limit = WORKSPACE_FILE_CONTENT_MAX) {
+    try {
+        return await readParameterAgentFile(root, path, limit);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw error;
+        throw new LevelEditorError('level_editor_file_invalid', [path]);
+    }
+}
+export async function readWorkspaceLevelEditor(root, revisions, context) {
+    const access = levelEditorContext(root, context);
+    if (access) {
+        registerLevelEditorContext(root, access);
+        try {
+            await recoverPendingLevelEditorTransaction(root, access, () => readLevelEditorSnapshot(root, revisions));
+        }
+        catch (error) {
+            const code = error instanceof LevelEditorError ? error.code : 'level_editor_recovery_required';
+            return {
+                status: 'invalid',
+                ...empty,
+                diagnostics: [{ code, message: code, severity: 'error' }],
+            };
+        }
+    }
+    const snapshot = await readLevelEditorSnapshot(root, revisions);
+    if (snapshot.status !== 'ready' || !snapshot.definition)
+        return snapshot;
+    try {
+        const diagnostics = [
+            ...snapshot.diagnostics,
+            ...(await validateLevelEditorExtensions(root, snapshot.definition, snapshot.documents)),
+        ];
+        if (diagnostics.length > 256)
+            throw new LevelEditorError('level_editor_extension_output_invalid');
+        return {
+            ...snapshot,
+            status: diagnostics.some((item) => item.severity === 'error') ? 'invalid' : 'ready',
+            diagnostics,
+        };
+    }
+    catch (error) {
+        const code = error instanceof LevelEditorError ? error.code : 'level_editor_extension_failed';
+        return {
+            ...snapshot,
+            status: 'invalid',
+            diagnostics: [
+                { code, message: code, severity: 'error' },
+                ...snapshot.diagnostics,
+            ].slice(0, 256),
+        };
+    }
+}
+async function readLevelEditorSnapshot(root, revisions) {
+    try {
+        let manifest;
+        try {
+            manifest = await readLevelEditorFile(root, '.playcraft/workspace.json');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { status: 'absent', ...empty };
+            throw error;
+        }
+        const workspaceManifest = JSON5.parse(manifest.toString('utf8'));
+        const raw = workspaceManifest.levelEditor;
+        if (raw === undefined)
+            return { status: 'absent', ...empty };
+        const declared = location.parse(raw);
+        const definitionBytes = await readLevelEditorFile(root, declared.definition);
+        const initial = compileLevelEditorDefinition(JSON5.parse(definitionBytes.toString('utf8')));
+        if (!initial.ok)
+            return {
+                status: 'invalid',
+                ...empty,
+                definitionPath: declared.definition,
+                diagnostics: initial.diagnostics,
+            };
+        const definition = initial.definition;
+        const documents = {}, schemas = {};
+        const documentHashes = {}, dataRevisions = {};
+        const sourceHashes = [];
+        for (const [id, document] of Object.entries(definition.documents)) {
+            const [data, schema] = await Promise.all([
+                readLevelEditorFile(root, document.path),
+                readLevelEditorFile(root, document.schema),
+            ]);
+            let text;
+            try {
+                text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(data);
+            }
+            catch {
+                throw new LevelEditorError('level_editor_document_invalid_utf8', [id]);
+            }
+            documents[id] = await parseLevelEditorDocument(root, document, text);
+            schemas[id] = JSON5.parse(schema.toString('utf8'));
+            documentHashes[id] = levelEditorDigest(data);
+            dataRevisions[id] = revisions[document.path]?.revision ?? 0;
+            sourceHashes.push([document.schema, levelEditorDigest(schema)]);
+        }
+        const checked = compileLevelEditorDefinition(definition, schemas);
+        const diagnostics = checked.diagnostics.concat(validateLevelEditorDocuments(definition, documents, schemas));
+        const { view: _view, labels: _labels, preview: _preview, ...bindingDefinition } = definition;
+        const bindingContractHash = levelEditorDigest(levelEditorCanonicalJson({ ...bindingDefinition, views: semanticViews(definition.view) }));
+        const schemaHash = levelEditorDigest(levelEditorCanonicalJson(sourceHashes.sort()));
+        const adapterInputs = [];
+        for (const path of levelEditorExtensionPaths(definition))
+            adapterInputs.push([path, levelEditorDigest(await readLevelEditorFile(root, path))]);
+        for (const path of [...new Set(Object.values(definition.preview ?? {}))])
+            adapterInputs.push([path, levelEditorDigest(await readLevelEditorFile(root, path))]);
+        const authoredData = new Set([
+            declared.definition,
+            '.playcraft/workspace.json',
+            ...Object.values(definition.documents).flatMap((document) => [
+                document.path,
+                document.schema,
+            ]),
+        ]);
+        // Conservatively cover authored transitive imports, instead of trusting an agent-maintained import list.
+        const sourceInputs = (await parameterInputSnapshot(root)).sources.filter((item) => !authoredData.has(item.path));
+        for (const path of workspaceManifest.previewRuntime?.gameFilePaths ?? []) {
+            workspaceRelativePathSchema.parse(path);
+            if (!authoredData.has(path))
+                adapterInputs.push([path, levelEditorDigest(await readLevelEditorFile(root, path))]);
+        }
+        const executionContractHash = levelEditorDigest(levelEditorCanonicalJson({
+            bindingContractHash,
+            schemaHash,
+            adapterInputs,
+            sourceInputs,
+            previewRuntime: workspaceManifest.previewRuntime ?? null,
+        }));
+        const sourceFingerprint = levelEditorDigest(levelEditorCanonicalJson({
+            definitionPath: declared.definition,
+            bindingContractHash,
+            schemaHash,
+            executionContractHash,
+        }));
+        return levelEditorSnapshotSchema.parse({
+            status: diagnostics.some((item) => item.severity === 'error') ? 'invalid' : 'ready',
+            definitionPath: declared.definition,
+            definition,
+            documents,
+            schemas,
+            revisions: dataRevisions,
+            documentHashes,
+            definitionHash: levelEditorDigest(definitionBytes),
+            sourceFingerprint,
+            bindingContractHash,
+            schemaHash,
+            executionContractHash,
+            diagnostics,
+        });
+    }
+    catch (error) {
+        const code = error instanceof LevelEditorError ? error.code : 'level_editor_document_invalid';
+        const diagnostics = [{ code, message: code, severity: 'error' }];
+        return { status: 'invalid', ...empty, diagnostics };
+    }
+}
+export async function transactWorkspaceLevelEditor(root, revisions, value, context) {
+    const request = levelEditorTransactionRequestSchema.parse(value);
+    if (request.version === 2)
+        return transactLevelEditorBatch(root, revisions, request, context, () => readLevelEditorSnapshot(root, revisions));
+    if (context) {
+        assertLevelEditorHistoryScope(context);
+        registerLevelEditorContext(root, context);
+    }
+    if (context && context.operation.clientRequestId !== request.requestId)
+        throw new LevelEditorError('level_editor_history_scope_invalid');
+    const snapshot = await readWorkspaceLevelEditor(root, revisions);
+    if (snapshot.status !== 'ready' || !snapshot.definition)
+        throw new LevelEditorError('level_editor_not_ready');
+    if (snapshot.definition.editorId !== request.editorId ||
+        snapshot.definition.dataContractVersion !== request.dataContractVersion)
+        throw new LevelEditorError('level_editor_contract_conflict');
+    for (const key of [
+        'sourceFingerprint',
+        'bindingContractHash',
+        'schemaHash',
+        'executionContractHash',
+    ])
+        if (snapshot[key] !== request[key])
+            throw new LevelEditorError('level_editor_source_conflict');
+    const previousReceipt = context && (await readLevelEditorHistory(root, context, request.requestId));
+    if (previousReceipt) {
+        if (previousReceipt.requestDigest !== levelEditorHistoryRequestDigest(request))
+            throw new LevelEditorError('level_editor_history_request_conflict');
+        const currentRevision = snapshot.revisions[request.documentId];
+        if (snapshot.documentHashes[request.documentId] === previousReceipt.contentHash &&
+            (currentRevision === request.expectedRevision ||
+                currentRevision === request.expectedRevision + 1)) {
+            if (snapshot.definition.documents[request.documentId]?.path !== previousReceipt.path)
+                throw new LevelEditorError('level_editor_history_invalid');
+            await writeLevelEditorHistory(root, context, { ...previousReceipt, phase: 'confirmed' });
+            return {
+                path: previousReceipt.path,
+                contentHash: previousReceipt.contentHash,
+                size: previousReceipt.size,
+                revision: request.expectedRevision + 1,
+            };
+        }
+        if (previousReceipt.phase === 'confirmed')
+            throw new LevelEditorError('revision_conflict');
+    }
+    if (snapshot.revisions[request.documentId] !== request.expectedRevision ||
+        snapshot.documentHashes[request.documentId] !== request.expectedDocumentHash)
+        throw new LevelEditorError('revision_conflict');
+    const command = {
+        commandId: request.commandId,
+        selection: request.selection,
+        input: request.input,
+    };
+    const originalReceipt = request.history &&
+        context &&
+        (await readLevelEditorHistory(root, context, request.history.requestId));
+    if (request.history) {
+        if (originalReceipt?.request.version !== 1)
+            throw new LevelEditorError('level_editor_history_missing');
+        if (!originalReceipt ||
+            originalReceipt.phase !== 'confirmed' ||
+            originalReceipt.request.history ||
+            request.history.requestId === request.requestId)
+            throw new LevelEditorError('level_editor_history_missing');
+        for (const key of [
+            'editorId',
+            'dataContractVersion',
+            'documentId',
+            'sourceFingerprint',
+            'bindingContractHash',
+            'schemaHash',
+            'executionContractHash',
+        ])
+            if (originalReceipt.request[key] !==
+                request[key])
+                throw new LevelEditorError('level_editor_source_conflict');
+        if (levelEditorCanonicalJson(originalReceipt.command) !== levelEditorCanonicalJson(command))
+            throw new LevelEditorError('level_editor_history_invalid');
+    }
+    const outcome = request.history
+        ? applyLevelEditorHistory(snapshot.definition, snapshot.documents, originalReceipt, request.history.direction, snapshot.schemas)
+        : applyLevelEditorCommand(snapshot.definition, snapshot.documents, command, snapshot.schemas);
+    if (outcome.documentId !== request.documentId)
+        throw new LevelEditorError('level_editor_document_mismatch');
+    const document = snapshot.definition.documents[request.documentId];
+    const original = await readLevelEditorFile(root, document.path);
+    if (levelEditorDigest(original) !== request.expectedDocumentHash)
+        throw new LevelEditorError('revision_conflict');
+    const candidate = { ...snapshot.documents, [outcome.documentId]: outcome.data };
+    if ((await validateLevelEditorExtensions(root, snapshot.definition, candidate)).some((item) => item.severity === 'error'))
+        throw new LevelEditorError('level_editor_validation_failed');
+    const source = original.toString('utf8');
+    const edited = await serializeLevelEditorDocument(root, document, source, outcome.changes, outcome.data);
+    if (!document.provider && document.format !== 'yaml' && document.path.endsWith('.json'))
+        JSON.parse(edited);
+    const bytes = Buffer.from(edited);
+    if (bytes.length > WORKSPACE_FILE_CONTENT_MAX)
+        throw new LevelEditorError('level_editor_document_budget');
+    const path = await resolveWorkspaceFile(root, document.path);
+    const previous = await lstat(path);
+    if (!previous.isFile() || previous.isSymbolicLink() || previous.nlink !== 1)
+        throw new LevelEditorError('level_editor_file_invalid');
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    const receipt = {
+        request,
+        requestDigest: levelEditorHistoryRequestDigest(request),
+        phase: 'prepared',
+        command,
+        documentId: request.documentId,
+        before: snapshot.documents[request.documentId],
+        after: outcome.data,
+        path: document.path,
+        contentHash: levelEditorDigest(bytes),
+        size: bytes.length,
+    };
+    if (context)
+        await writeLevelEditorHistory(root, context, receipt);
+    try {
+        const handle = await openSharedFile(root, temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW);
+        try {
+            await handle.writeFile(bytes);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        if (context)
+            assertLevelEditorHistoryScope(context);
+        const latest = await readLevelEditorSnapshot(root, revisions);
+        if (latest.sourceFingerprint !== snapshot.sourceFingerprint ||
+            latest.documentHashes[request.documentId] !== request.expectedDocumentHash)
+            throw new LevelEditorError('level_editor_source_conflict');
+        if (context) {
+            assertLevelEditorHistoryScope(context);
+            if (context.state.journal?.destroyed() ||
+                (context.operation.leaseFence ?? 0) < context.state.acceptedLeaseFence)
+                throw new LevelEditorError('level_editor_source_conflict');
+        }
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    if (context) {
+        try {
+            await writeLevelEditorHistory(root, context, { ...receipt, phase: 'confirmed' });
+        }
+        catch {
+            throw new LevelEditorError('level_editor_transaction_uncertain');
+        }
+    }
+    return {
+        path: document.path,
+        contentHash: levelEditorDigest(bytes),
+        size: bytes.length,
+        revision: request.expectedRevision + 1,
+    };
+}
+/** Reconcile private proof; a batch resumes only its previously authorized durable intent. */
+export async function reconcileWorkspaceLevelEditorTransaction(root, revisions, value, context) {
+    const request = levelEditorTransactionRequestSchema.parse(value);
+    if (context.operation.clientRequestId !== request.requestId)
+        return undefined;
+    if (request.version === 2) {
+        await recoverPendingLevelEditorTransaction(root, context, () => readLevelEditorSnapshot(root, revisions));
+        let receipt = await readLevelEditorHistory(root, context, request.requestId);
+        if (receipt?.batch &&
+            receipt.phase === 'prepared' &&
+            receipt.requestDigest === levelEditorHistoryRequestDigest(request)) {
+            await transactLevelEditorBatch(root, revisions, request, context, () => readLevelEditorSnapshot(root, revisions));
+            receipt = await readLevelEditorHistory(root, context, request.requestId);
+        }
+        if (!receipt?.batch ||
+            receipt.phase !== 'confirmed' ||
+            receipt.batch.operationId !== context.operation.operationId ||
+            receipt.requestDigest !== levelEditorHistoryRequestDigest(request))
+            return undefined;
+        const snapshot = await readLevelEditorSnapshot(root, revisions);
+        if (snapshot.status !== 'ready' ||
+            snapshot.definition?.editorId !== request.editorId ||
+            snapshot.definition.dataContractVersion !== request.dataContractVersion ||
+            ['sourceFingerprint', 'bindingContractHash', 'schemaHash', 'executionContractHash'].some((key) => snapshot[key] !== request[key]) ||
+            JSON.stringify(Object.keys(snapshot.definition.documents).sort()) !==
+                JSON.stringify(Object.keys(request.expectedDocuments).sort()) ||
+            Object.entries(receipt.batch.baselines).some(([id, baseline]) => {
+                const file = receipt.batch.files.find((file) => file.documentId === id), revision = snapshot.revisions[id];
+                return (snapshot.definition.documents[id]?.path !== baseline.path ||
+                    snapshot.documentHashes[id] !== (file?.contentHash ?? baseline.contentHash) ||
+                    (file
+                        ? revision !== baseline.revision && revision !== file.revision
+                        : revision !== baseline.revision));
+            }))
+            return undefined;
+        const results = receipt.batch.files.map(({ documentId, path, contentHash, size, revision }) => ({
+            documentId,
+            path,
+            contentHash,
+            size,
+            revision,
+        }));
+        for (const item of results)
+            snapshot.revisions[item.documentId] = item.revision;
+        return { ...results[0], results, snapshot };
+    }
+    const receipt = await readLevelEditorHistory(root, context, request.requestId);
+    if (!receipt || receipt.requestDigest !== levelEditorHistoryRequestDigest(request))
+        return undefined;
+    const snapshot = await readWorkspaceLevelEditor(root, revisions);
+    if (snapshot.status !== 'ready' ||
+        !snapshot.definition ||
+        snapshot.definition.editorId !== request.editorId ||
+        snapshot.definition.dataContractVersion !== request.dataContractVersion ||
+        snapshot.definition.documents[request.documentId]?.path !== receipt.path)
+        return undefined;
+    for (const key of [
+        'sourceFingerprint',
+        'bindingContractHash',
+        'schemaHash',
+        'executionContractHash',
+    ])
+        if (snapshot[key] !== request[key])
+            return undefined;
+    const revision = snapshot.revisions[request.documentId];
+    if (snapshot.documentHashes[request.documentId] !== receipt.contentHash ||
+        (revision !== request.expectedRevision && revision !== request.expectedRevision + 1) ||
+        levelEditorCanonicalJson(snapshot.documents[request.documentId]) !==
+            levelEditorCanonicalJson(receipt.after))
+        return undefined;
+    await writeLevelEditorHistory(root, context, { ...receipt, phase: 'confirmed' });
+    const nextRevision = request.expectedRevision + 1;
+    snapshot.revisions[request.documentId] = nextRevision;
+    return {
+        path: receipt.path,
+        contentHash: receipt.contentHash,
+        size: receipt.size,
+        revision: nextRevision,
+        snapshot,
+    };
+}

package/dist/workspace-runtime/workspaces/parameter-initialization-skill.js

@@ -8,8 +8,7 @@ import { excludeFromGit } from './dependencies.js';
 import { ensureSharedDirectory, openSharedFile, shareIfNeeded } from './shared-write.js';
 import { acquireParameterSkillLease, readParameterSkillTransactionFile, writeParameterSkillTransaction } from './parameter-initialization-skill-transaction.js';
 export const PARAMETER_INITIALIZATION_SKILL = 'playcraft-runtime-parameters';
-const sourceRoot = `.agents/skills/${PARAMETER_INITIALIZATION_SKILL}`;
-const skillRef = `builtin/${PARAMETER_INITIALIZATION_SKILL}`;
+const profile = (name) => ({ sourceRoot: `.agents/skills/${name}`, skillRef: `builtin/${name}` });
 const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
 async function safeDirectory(root, path) {
     let current = root;
@@ -48,7 +47,8 @@ async function optionalFile(path) {
         throw error;
     }
 }
-async function installSource(root, files, token) {
+async function installSource(root, files, token, name) {
+    const { sourceRoot } = profile(name);
     const directory = join(root, sourceRoot);
     const staging = await safeDirectory(root, `.playcraft/parameter-initialization-${token}`);
     const temporary = join(staging, 'source');
@@ -98,9 +98,10 @@ function snapshot(originalDeclaration, originalLock) {
     const declaration = { schemaVersion: 1, entries: [] };
     return { declaration, lock: { lockVersion: 3, declarationHash: declarationDigest(declaration), entries: [] } };
 }
-function selectedSnapshot(previous, templateHash, artifactHash) {
+function selectedSnapshot(previous, templateHash, artifactHash, name) {
+    const { sourceRoot, skillRef } = profile(name);
     const next = structuredClone(previous);
-    const matches = next.declaration.entries.filter(entry => entry.entryKey === PARAMETER_INITIALIZATION_SKILL
+    const matches = next.declaration.entries.filter(entry => entry.entryKey === name
         || entry.source.skillRef === skillRef || entry.source.kind === 'repository' && entry.source.root === sourceRoot);
     if (matches.length > 1)
         throw new Error('workspace_skills_parameter_conflict');
@@ -111,24 +112,52 @@ function selectedSnapshot(previous, templateHash, artifactHash) {
         if (existing.source.kind !== 'repository' || existing.source.root !== sourceRoot
             || existing.source.skillRef !== skillRef || existing.surface !== 'sandbox-agent' || existing.projectFiles?.length
             || locked.dependencies.length || locked.revision.kind !== 'source' || locked.sourceTreeHash !== templateHash
-            || locked.revision.artifactHash !== artifactHash)
+            || (next.lock.lockVersion === 3 && locked.revision.artifactHash !== artifactHash)
+            || (next.lock.lockVersion === 4 && locked.revision.contentHash !== templateHash))
             throw new Error('workspace_skills_parameter_conflict');
         selected = existing;
         selected.enabled = true;
     }
     else {
-        selected = { entryKey: PARAMETER_INITIALIZATION_SKILL, source: { kind: 'repository', root: sourceRoot, skillRef },
+        selected = { entryKey: name, source: { kind: 'repository', root: sourceRoot, skillRef },
             enabled: true, surface: 'sandbox-agent' };
         const locked = { entryKey: selected.entryKey, sourceTreeHash: templateHash,
-            revision: { kind: 'source', skillRef, sourceRevision: `src-v1-sha256:${templateHash}`, artifactHash },
+            revision: { kind: 'source', skillRef, sourceRevision: `src-v1-sha256:${templateHash}`, artifactHash,
+                ...(next.lock.lockVersion === 4 ? { contentHash: templateHash } : {}) },
             dependencies: [], dependencyLockHash: dependencyDigest([], []) };
         next.declaration.entries.push(selected);
-        next.lock.entries.push(locked);
+        next.lock = { ...next.lock, entries: [...next.lock.entries, locked] };
     }
     next.lock.declarationHash = declarationDigest(next.declaration);
     validateProjectSkillsSnapshot(next.declaration, next.lock);
     return { next, selected, sourceAdded: !existing };
 }
+async function preservedSelectionSource(root, previous, name) {
+    const { sourceRoot, skillRef } = profile(name);
+    const matches = previous.declaration.entries.filter(entry => entry.entryKey === name || entry.source.skillRef === skillRef
+        || entry.source.kind === 'repository' && entry.source.root === sourceRoot);
+    if (matches.length > 1)
+        throw new Error('workspace_skills_parameter_conflict');
+    const selected = matches[0];
+    if (!selected)
+        return undefined;
+    const locked = previous.lock.entries.find(entry => entry.entryKey === selected.entryKey);
+    if (!locked || selected.source.kind !== 'repository' || selected.source.root !== sourceRoot || selected.source.skillRef !== skillRef
+        || selected.surface !== 'sandbox-agent' || selected.projectFiles?.length || locked.dependencies.length
+        || locked.revision.kind !== 'source' || !locked.sourceTreeHash
+        || locked.revision.sourceRevision !== `src-v1-sha256:${locked.sourceTreeHash}`)
+        throw new Error('workspace_skills_parameter_conflict');
+    const source = await readProjectSkillSource(root, selected);
+    if (source.sourceTreeHash !== locked.sourceTreeHash)
+        throw new Error('workspace_skills_source_changed');
+    const archive = createCanonicalBundleArchive(source.files.map(file => ({ path: file.path, data: Buffer.from(file.content) })));
+    const artifactHash = digest(archive);
+    if (previous.lock.lockVersion === 3 && artifactHash !== locked.revision.artifactHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    if (previous.lock.lockVersion === 4 && source.sourceTreeHash !== locked.revision.contentHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    return { source, archive, artifactHash };
+}
 async function cleanStaging(root, transaction, files, archive) {
     const directory = join(root, '.playcraft', `parameter-initialization-${transaction.owner.token}`);
     const expected = new Map(files.map(file => [`source/${file.path}`, Buffer.from(file.content)]));
@@ -168,14 +197,15 @@ async function cleanStaging(root, transaction, files, archive) {
         }
     }
 }
-async function recoverTransaction(root, transaction, template, artifactHash, archive) {
+async function recoverTransaction(root, transaction, template, artifactHash, archive, name) {
+    const { sourceRoot } = profile(name);
     if (transaction.templateHash !== template.sourceTreeHash || transaction.artifactHash !== artifactHash)
         throw new Error('workspace_skills_parameter_recovery_conflict');
     const originalDeclaration = transaction.originalDeclaration === null ? undefined : Buffer.from(transaction.originalDeclaration, 'base64');
     if (originalDeclaration && originalDeclaration.toString('base64') !== transaction.originalDeclaration)
         throw new Error('workspace_skills_parameter_recovery_conflict');
     const previous = snapshot(originalDeclaration, transaction.originalLock);
-    const { next, selected, sourceAdded } = selectedSnapshot(previous, template.sourceTreeHash, artifactHash);
+    const { next, selected, sourceAdded } = selectedSnapshot(previous, template.sourceTreeHash, artifactHash, name);
     if (sourceAdded !== transaction.sourceAdded || `${canonicalProjectSkillsJson(next.declaration)}\n` !== transaction.nextDeclaration
         || `${canonicalProjectSkillsJson(next.lock)}\n` !== transaction.nextLock)
         throw new Error('workspace_skills_parameter_recovery_conflict');
@@ -212,22 +242,24 @@ async function recoverTransaction(root, transaction, template, artifactHash, arc
     await cleanStaging(root, transaction, template.files, archive);
 }
 /** A deliberate initialization selects one versioned project skill without synchronizing other sources. */
-export async function ensureParameterInitializationSkill(root) {
+export async function ensureParameterInitializationSkill(root, name = PARAMETER_INITIALIZATION_SKILL, options = {}) {
+    const { sourceRoot, skillRef } = profile(name);
     const rootStat = await lstat(root);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
         throw new Error('workspace_skills_invalid');
-    const templateEntry = { entryKey: PARAMETER_INITIALIZATION_SKILL,
-        source: { kind: 'repository', root: `project-template/.claude/skills/${PARAMETER_INITIALIZATION_SKILL}`, skillRef },
+    const templateEntry = { entryKey: name,
+        source: { kind: 'repository', root: `project-template/.claude/skills/${name}`, skillRef },
         enabled: true, surface: 'sandbox-agent' };
-    const template = await readProjectSkillSource(resolveCliPackageRoot(), templateEntry);
-    const archive = createCanonicalBundleArchive(template.files.map(file => ({ path: file.path, data: Buffer.from(file.content) })));
-    const artifactHash = digest(archive);
+    const bundledTemplate = await readProjectSkillSource(resolveCliPackageRoot(), templateEntry);
+    const bundledArchive = createCanonicalBundleArchive(bundledTemplate.files.map(file => ({ path: file.path, data: Buffer.from(file.content) })));
+    const bundledArtifactHash = digest(bundledArchive);
     await excludeFromGit(root, '/.playcraft/skills/');
     await excludeFromGit(root, '/.playcraft/skill-artifacts/');
     await excludeFromGit(root, '/.playcraft/skills-write.lock');
     await excludeFromGit(root, '/.playcraft/parameter-initialization-*');
     const management = await safeDirectory(root, '.playcraft');
-    const lease = await acquireParameterSkillLease(management, transaction => recoverTransaction(root, transaction, template, artifactHash, archive));
+    const lease = await acquireParameterSkillLease(management, transaction => recoverTransaction(root, transaction, bundledTemplate, bundledArtifactHash, bundledArchive, name));
+    let template = bundledTemplate, archive = bundledArchive, artifactHash = bundledArtifactHash;
     const staged = [];
     let ownedSource = false, committed = false, cleanupAllowed = true;
     let removeTransaction;
@@ -236,7 +268,15 @@ export async function ensureParameterInitializationSkill(root) {
         const originalDeclaration = await optionalFile(declarationPath);
         const originalLock = await readProjectSkillsLockFile(root);
         const previous = snapshot(originalDeclaration, originalLock);
-        const { next, selected, sourceAdded } = selectedSnapshot(previous, template.sourceTreeHash, artifactHash);
+        if (options.preserveExisting) {
+            const preserved = await preservedSelectionSource(root, previous, name);
+            if (preserved) {
+                template = preserved.source;
+                archive = preserved.archive;
+                artifactHash = preserved.artifactHash;
+            }
+        }
+        const { next, selected, sourceAdded } = selectedSnapshot(previous, template.sourceTreeHash, artifactHash, name);
         if (!sourceAdded) {
             if ((await readProjectSkillSource(root, selected)).sourceTreeHash !== template.sourceTreeHash)
                 throw new Error('workspace_skills_source_changed');
@@ -249,7 +289,7 @@ export async function ensureParameterInitializationSkill(root) {
         }
         else {
             for (const source of PROJECT_SKILL_SOURCE_ROOTS) {
-                const path = join(root, source, PARAMETER_INITIALIZATION_SKILL);
+                const path = join(root, source, name);
                 const exists = await lstat(path).then(() => true, error => {
                     if (error.code === 'ENOENT')
                         return false;
@@ -265,7 +305,7 @@ export async function ensureParameterInitializationSkill(root) {
                 originalDeclaration: originalDeclaration?.toString('base64') ?? null, originalLock,
                 nextDeclaration: `${canonicalProjectSkillsJson(next.declaration)}\n`, nextLock: `${canonicalProjectSkillsJson(next.lock)}\n` });
             if (sourceAdded) {
-                await installSource(root, template.files, lease.owner.token);
+                await installSource(root, template.files, lease.owner.token, name);
                 ownedSource = true;
             }
             await preserveArtifact(root, artifactHash, archive, lease.owner.token);
@@ -313,7 +353,7 @@ export async function ensureParameterInitializationSkill(root) {
     }
     finally {
         if (cleanupAllowed && ownedSource && !committed) {
-            const entry = { entryKey: PARAMETER_INITIALIZATION_SKILL,
+            const entry = { entryKey: name,
                 source: { kind: 'repository', root: sourceRoot }, enabled: true, surface: 'sandbox-agent' };
             if ((await readProjectSkillSource(root, entry)).sourceTreeHash !== template.sourceTreeHash)
                 throw new Error('workspace_skills_source_changed');

package/dist/workspace-runtime/workspaces/parameter-production.js

@@ -5,7 +5,7 @@ import { z } from 'zod';
 import { workspaceRelativePathSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { ParameterAgentError, parameterDigest, readParameterAgentFile } from './parameter-agent-inputs.js';
 const reportPath = '.playcraft-editor-preview/release-report.json';
-const marker = /runtime\.parameters\.|playcraft-preview-storage:|__playcraft_preview_context__/i;
+const marker = /runtime\.(?:parameters|levelEditor|level-editor)\.|playcraft-preview-storage:|__playcraft_(?:preview|level_editor)_context__|playcraft-level-editor-profile/i;
 const slash = (value) => value.replaceAll('\\', '/').replaceAll('\0', '').split('?')[0];
 const relativePath = z.string().refine(value => workspaceRelativePathSchema.safeParse(value).success);
 const reportSchema = z.object({