@playcraft/cli 0.1.60-beta → 0.1.61-beta

package/dist/workspace-runtime/workspaces/procedural-3d/host.js

@@ -0,0 +1,595 @@
+import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { lstat, readFile, readdir, rmdir } from 'node:fs/promises';
+import { extname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import { ProductionSkillFailure } from '../../codex/production-skill-tools.js';
+import { withDirectoryOwner } from '../../server/directory-access.js';
+import { runSkillCommand } from '../../processes/skill-command.js';
+import { resolveActiveSkillExecutionContext } from '../skill-execution-context.js';
+import { freezeWorkspaceSkills } from '../skills.js';
+import { loadWorkspaceSkillArtifact } from '../skill-artifact-loader.js';
+import { ensureSharedDirectory, writeSharedFile } from '../shared-write.js';
+import { checkedFile, digest, verifyFiles, writeControlJson } from './files.js';
+import { adoptCandidate, freezeCandidate, verifyCandidate, candidateWorkspaceFiles, } from './candidate.js';
+import { requestSchema, captureSchema } from './contracts.js';
+import { captureV2Schema, reviewProfileHash, validateRenderReceipt } from './review-contracts.js';
+function verifyControlledSpecChange(before, after, action, kind) {
+    const previous = structuredClone(before), current = structuredClone(after);
+    if (action === 'tier1-diagnostics') {
+        const oldRows = previous.tier1Results ?? [], newRows = current.tier1Results;
+        if (!Array.isArray(oldRows) ||
+            !Array.isArray(newRows) ||
+            newRows.length !== oldRows.length + 1 ||
+            !isDeepStrictEqual(oldRows, newRows.slice(0, -1)))
+            throw new Error('procedural_skill_unexpected_diagnostic_change');
+        delete previous.tier1Results;
+        delete current.tier1Results;
+    }
+    else if (action === 'request-correction') {
+        const oldRows = previous.reviewHistory ?? [], newRows = current.reviewHistory;
+        const correction = Array.isArray(newRows) ? newRows.at(-1) : undefined;
+        if (!Array.isArray(oldRows) ||
+            !Array.isArray(newRows) ||
+            newRows.length !== oldRows.length + 1 ||
+            !isDeepStrictEqual(oldRows, newRows.slice(0, -1)) ||
+            correction?.reviewType !== 'diagnostic-correction' ||
+            correction?.action !== kind ||
+            correction?.aiVisionScore !== undefined ||
+            correction?.estimatedFidelity !== undefined)
+            throw new Error('procedural_skill_unexpected_correction_change');
+        delete previous.reviewHistory;
+        delete current.reviewHistory;
+    }
+    else if (action === 'pipeline-sync') {
+        delete previous.sculptPipeline;
+        delete current.sculptPipeline;
+    }
+    if (!isDeepStrictEqual(previous, current))
+        throw new Error('procedural_skill_unexpected_diagnostic_change');
+}
+export function proceduralSkillHandler(state) {
+    return (request, context, signal) => execute(state, request, context, signal);
+}
+async function execute(state, raw, context, signal) {
+    const parsed = requestSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new Error('procedural_skill_invalid_arguments');
+    const request = parsed.data;
+    const binding = await resolveActiveSkillExecutionContext(state, context);
+    return withDirectoryOwner(state, binding.operation, `operation:${binding.operation.operationId}`, async () => {
+        const root = context.root;
+        const frozen = await freezeWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'), (entry) => loadWorkspaceSkillArtifact(state, binding.operation.workspaceId, entry, binding.operation.directoryName));
+        if (frozen.lockHash !== binding.lockHash)
+            throw new Error('context_skills_changed');
+        const skillRoot = join(root, '.playcraft/skills', binding.lockHash, binding.entry.entryKey);
+        const descriptorBytes = await checkedFile(skillRoot, 'capability.json');
+        const descriptor = JSON.parse(descriptorBytes.toString('utf8'));
+        if (descriptor.id !== 'playcraft.procedural-3d' ||
+            ![1, 2].includes(descriptor.hostProtocolVersion) ||
+            descriptor.entrypoint !== 'adapter/entry.mjs')
+            throw new Error('procedural_skill_incompatible');
+        const runId = request.runId ?? (request.action === 'prepare' ? randomUUID() : undefined);
+        if (!runId && !['describe', 'preflight'].includes(request.action))
+            throw new Error('procedural_skill_run_required');
+        const jobRoot = join(root, '.playcraft/procedural-3d/runs', runId ?? 'preflight');
+        const controlPath = join(state.config.stateDir, 'procedural-3d', digest(root), `${runId}.json`);
+        const current = async () => {
+            if (signal.aborted)
+                throw new Error('procedural_skill_cancelled');
+            const now = await resolveActiveSkillExecutionContext(state, context);
+            if (now.lockHash !== binding.lockHash ||
+                now.entry.revision.artifactHash !== binding.entry.revision.artifactHash)
+                throw new Error('context_skills_changed');
+        };
+        const guard = async (run) => {
+            for (const [path, hash] of [
+                ['adapter-state.json', run.adapterStateHash],
+                ['workspace/.img2threejs/state.json', run.upstreamStateHash],
+            ])
+                if (hash && digest(await checkedFile(jobRoot, path)) !== hash)
+                    throw new Error('procedural_skill_state_changed');
+        };
+        const saveGuards = async (run) => {
+            run.adapterStateHash = digest(await checkedFile(jobRoot, 'adapter-state.json'));
+            run.upstreamStateHash = digest(await checkedFile(jobRoot, 'workspace/.img2threejs/state.json'));
+        };
+        const adapter = async (action, input = {}) => {
+            await current();
+            const result = await runSkillCommand(state, {
+                scope: binding.operation,
+                cwd: root,
+                argv: [process.execPath, join(skillRoot, 'adapter/entry.mjs')],
+                signal,
+                input: {
+                    protocolVersion: 1,
+                    action,
+                    input,
+                    context: {
+                        jobRoot,
+                        skillLockHash: binding.lockHash,
+                        skillArtifactHash: binding.entry.revision.artifactHash,
+                    },
+                },
+            });
+            await current();
+            let reply;
+            try {
+                reply = JSON.parse(result.stdout);
+            }
+            catch {
+                throw new Error('procedural_skill_invalid_response');
+            }
+            if (reply.protocolVersion !== 1 || typeof reply.ok !== 'boolean')
+                throw new Error('procedural_skill_invalid_response');
+            if (!reply.ok || result.code !== 0) {
+                const code = typeof reply.error?.code === 'string' && /^[a-z0-9-]{1,80}$/.test(reply.error.code)
+                    ? reply.error.code
+                    : 'adapter-failed';
+                const reportPath = reply.error?.reportPath;
+                if (typeof reportPath === 'string' &&
+                    /^reports\/[a-zA-Z0-9_-]+\.json$/.test(reportPath)) {
+                    await checkedFile(jobRoot, reportPath);
+                    throw new ProductionSkillFailure(`procedural_skill:${code}`, relative(root, join(jobRoot, reportPath)));
+                }
+                throw new Error(`procedural_skill:${code}`);
+            }
+            const failure = reply.result?.diagnosticFailure;
+            if (failure) {
+                if (typeof failure.reportPath !== 'string' ||
+                    !/^reports\/[a-zA-Z0-9_-]+\.json$/.test(failure.reportPath))
+                    throw new Error('procedural_skill_invalid_report');
+                if (digest(await checkedFile(jobRoot, failure.reportPath)) !== failure.reportHash)
+                    throw new Error('procedural_skill_invalid_report');
+                return {
+                    ...reply.result,
+                    diagnosticFailure: {
+                        ...failure,
+                        reportPath: relative(root, join(jobRoot, failure.reportPath)),
+                    },
+                };
+            }
+            return reply.result;
+        };
+        if (request.action === 'describe' || request.action === 'preflight')
+            return adapter(request.action);
+        let run;
+        try {
+            run = JSON.parse(await readFile(controlPath, 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (request.action === 'prepare') {
+            const input = z
+                .object({
+                referencePath: z.string(),
+                name: z.string().min(1).max(160),
+                maxPerPass: z.number().int().min(1).max(3).optional(),
+                maxTotal: z.number().int().min(1).max(6).optional(),
+            })
+                .strict()
+                .parse(request.input);
+            const bytes = await checkedFile(root, input.referencePath);
+            const extension = extname(input.referencePath).toLowerCase();
+            if (!['.png', '.jpg', '.jpeg'].includes(extension))
+                throw new Error('procedural_skill_reference_format');
+            if (run) {
+                if (run.referenceHash !== digest(bytes) ||
+                    run.lockHash !== binding.lockHash ||
+                    run.artifactHash !== binding.entry.revision.artifactHash)
+                    throw new Error('procedural_skill_run_conflict');
+                return { runId, revision: run.revision, status: run.status, jobRoot, resumed: true };
+            }
+            const environment = await adapter('preflight');
+            await ensureSharedDirectory(root, jobRoot);
+            const referencePath = `input/reference${extension}`;
+            await writeSharedFile(root, join(jobRoot, referencePath), bytes);
+            run = {
+                schemaVersion: 1,
+                runId: runId,
+                revision: 0,
+                root,
+                lockHash: binding.lockHash,
+                artifactHash: binding.entry.revision.artifactHash,
+                referencePath,
+                referenceHash: digest(bytes),
+                descriptorHash: digest(descriptorBytes),
+                hostProtocolVersion: descriptor.hostProtocolVersion,
+                operationId: binding.operation.operationId,
+                status: 'preparing',
+                environment,
+                candidates: [],
+                receipts: [],
+            };
+            await writeControlJson(controlPath, run);
+            try {
+                const result = await adapter('prepare', {
+                    ...input,
+                    referencePath,
+                    referenceSha256: run.referenceHash,
+                });
+                run.status = 'prepared';
+                run.revision++;
+                await saveGuards(run);
+                await writeControlJson(controlPath, run);
+                return { runId, revision: run.revision, jobRoot, ...result };
+            }
+            catch (error) {
+                run.status = 'uncertain';
+                run.lastError = error instanceof Error ? error.message : 'prepare_failed';
+                run.lastReportPath =
+                    error instanceof ProductionSkillFailure ? error.reportPath : undefined;
+                await writeControlJson(controlPath, run);
+                throw error;
+            }
+        }
+        if (!run || run.root !== root)
+            throw new Error('procedural_skill_run_missing');
+        if (run.lockHash !== binding.lockHash ||
+            run.artifactHash !== binding.entry.revision.artifactHash ||
+            run.descriptorHash !== digest(descriptorBytes) ||
+            (run.hostProtocolVersion ?? 1) !== descriptor.hostProtocolVersion)
+            throw new Error('blocked-lock-mismatch');
+        if (digest(await checkedFile(jobRoot, run.referencePath)) !== run.referenceHash)
+            throw new Error('procedural_skill_reference_changed');
+        await guard(run);
+        if (request.action === 'status')
+            return {
+                runId,
+                revision: run.revision,
+                jobRoot,
+                runStatus: run.status,
+                lastError: run.lastError,
+                reportPath: run.lastReportPath,
+                environment: run.environment,
+                candidates: run.candidates,
+                ...(await adapter('status')),
+                ...(descriptor.hostProtocolVersion === 2 ? { referenceHash: run.referenceHash } : {}),
+            };
+        if (request.expectedRevision !== run.revision)
+            throw new Error('procedural_skill_revision_conflict');
+        if (['uncertain', 'running'].includes(run.status) && request.action !== 'recover')
+            throw new Error('procedural_skill_recovery_required');
+        if (request.action === 'recover' && (!run.adapterStateHash || !run.upstreamStateHash))
+            throw new Error('procedural_skill_recovery_required');
+        run.revision++;
+        run.status = 'running';
+        run.operationId = binding.operation.operationId;
+        await writeControlJson(controlPath, run);
+        try {
+            const candidate = run.candidates.at(-1);
+            let result;
+            if (request.action === 'recover') {
+                if (Object.keys(request.input).length)
+                    throw new Error('procedural_skill_invalid_arguments');
+                const scope = state.config.workspaceMode === 'multi'
+                    ? `${binding.operation.workspaceId}:${binding.operation.directoryName ?? 'basic'}`
+                    : 'basic';
+                if (state.journal
+                    .listManagedWrites()
+                    .some((item) => item.workspaceId === scope && !item.stoppedAt))
+                    throw new Error('procedural_skill_stop_unconfirmed');
+                const marker = join(jobRoot, '.adapter-running');
+                const stat = await lstat(marker).catch((error) => {
+                    if (error.code === 'ENOENT')
+                        return undefined;
+                    throw error;
+                });
+                if (stat) {
+                    if (!stat.isDirectory() || stat.isSymbolicLink() || (await readdir(marker)).length)
+                        throw new Error('procedural_skill_recovery_required');
+                    await rmdir(marker);
+                }
+                // guard() above compared the control-owned checkpoint. A partial upstream commit remains
+                // blocked instead of silently accepting new state or resetting its correction budget.
+                result = await adapter('status');
+            }
+            else if (request.action === 'capture') {
+                const input = descriptor.hostProtocolVersion === 2
+                    ? captureV2Schema.parse(request.input)
+                    : captureSchema.parse(request.input), status = await adapter('status');
+                if (status.currentStep !== 'render-capture' || typeof status.currentPass !== 'string')
+                    throw new Error('procedural_skill_out_of_order');
+                const review = 'review' in input ? input.review : undefined;
+                if (review &&
+                    run.reviewProfile &&
+                    reviewProfileHash(review.profile) !== run.reviewProfile.hash)
+                    throw new Error('procedural_skill_review_profile_changed');
+                const helpers = review
+                    ? {
+                        scene: await checkedFile(skillRoot, 'adapter/review-scene.mjs'),
+                        profile: await checkedFile(skillRoot, 'adapter/review-profile.mjs'),
+                    }
+                    : undefined;
+                const fresh = await freezeCandidate(root, jobRoot, {
+                    ...input,
+                    views: [...new Set(input.views)],
+                    passId: status.currentPass,
+                }, helpers);
+                const outputRoot = join(jobRoot, 'candidates', fresh.id, 'captures');
+                const render = await runSkillCommand(state, {
+                    scope: binding.operation,
+                    cwd: root,
+                    signal,
+                    argv: [process.execPath, fileURLToPath(new URL('./render-worker.js', import.meta.url))],
+                    input: {
+                        projectRoot: root,
+                        sourceRoot: join(jobRoot, 'candidates', fresh.id, 'source'),
+                        outputRoot,
+                        pagePath: fresh.pagePath,
+                        views: fresh.views,
+                        referencePath: join(jobRoot, run.referencePath),
+                        ...(fresh.hostReview
+                            ? {
+                                reviewProfile: {
+                                    profile: fresh.hostReview.profile,
+                                    hash: fresh.hostReview.profileHash,
+                                },
+                            }
+                            : {}),
+                    },
+                });
+                if (render.code !== 0) {
+                    const reportPath = `reports/host-render-${randomUUID()}.json`;
+                    await writeSharedFile(root, join(jobRoot, reportPath), JSON.stringify({
+                        kind: 'render-failure',
+                        ...(fresh.hostReview
+                            ? {
+                                candidateId: fresh.id,
+                                sourceHash: fresh.sourceHash,
+                                reviewProfileHash: fresh.hostReview.profileHash,
+                            }
+                            : {}),
+                        code: render.code,
+                        stdout: render.stdout.slice(-65536),
+                        stderr: render.stderr.slice(-65536),
+                    }));
+                    throw new ProductionSkillFailure('procedural_skill_render_failed', relative(root, join(jobRoot, reportPath)));
+                }
+                try {
+                    const report = JSON.parse(render.stdout);
+                    if (report.ok !== true || !Array.isArray(report.result?.captures))
+                        throw new Error('procedural_skill_render_failed');
+                    if (fresh.hostReview) {
+                        const expected = [...fresh.views, 'map-stripped', 'comparison'];
+                        if (report.result.captures.length !== expected.length ||
+                            new Set(report.result.captures.map((capture) => capture.view))
+                                .size !== expected.length ||
+                            report.result.captures.some((capture) => !expected.includes(capture.view) || capture.file !== `${capture.view}.png`))
+                            throw new Error('procedural_skill_review_capture_mismatch');
+                    }
+                    fresh.captures = await Promise.all(report.result.captures.map(async (item) => {
+                        const path = `candidates/${fresh.id}/captures/${item.file}`;
+                        return { path, view: item.view, hash: digest(await checkedFile(jobRoot, path)) };
+                    }));
+                    fresh.render = report.result;
+                    if (fresh.hostReview) {
+                        const { renderReceipt: receipt, ...summary } = report.result;
+                        fresh.render = summary;
+                        if (receipt?.file !== 'render-state.json')
+                            throw new Error('procedural_skill_review_receipt_missing');
+                        const path = `candidates/${fresh.id}/captures/render-state.json`;
+                        const bytes = await checkedFile(jobRoot, path);
+                        if (receipt.hash !== digest(bytes))
+                            throw new Error('procedural_skill_review_receipt_changed');
+                        validateRenderReceipt(JSON.parse(bytes.toString('utf8')), fresh.hostReview.profile, fresh.views);
+                        fresh.renderReceipt = { path, hash: digest(bytes) };
+                    }
+                    await verifyCandidate(root, jobRoot, fresh);
+                }
+                catch (error) {
+                    if (!fresh.hostReview)
+                        throw error;
+                    const reportPath = `reports/host-render-contract-${randomUUID()}.json`;
+                    await writeSharedFile(root, join(jobRoot, reportPath), JSON.stringify({
+                        kind: 'render-review-contract-failure',
+                        candidateId: fresh.id,
+                        sourceHash: fresh.sourceHash,
+                        reviewProfileHash: fresh.hostReview.profileHash,
+                        reason: 'render-state-or-capture-mismatch',
+                    }));
+                    throw new ProductionSkillFailure('procedural_skill_review_state_invalid', relative(root, join(jobRoot, reportPath)));
+                }
+                await current();
+                if (!fresh.hostReview)
+                    run.candidates.push(fresh);
+                await writeSharedFile(root, join(jobRoot, `candidates/${fresh.id}/capture.json`), JSON.stringify(fresh, null, 2));
+                result = await adapter('host-receipt', {
+                    stepId: 'render-capture',
+                    evidence: [`candidates/${fresh.id}/capture.json`],
+                });
+                if (fresh.hostReview) {
+                    run.candidates.push(fresh);
+                    if (!run.reviewProfile)
+                        run.reviewProfile = {
+                            profile: fresh.hostReview.profile,
+                            hash: fresh.hostReview.profileHash,
+                        };
+                }
+            }
+            else if (request.action === 'review') {
+                if (!candidate)
+                    throw new Error('procedural_skill_candidate_missing');
+                await verifyCandidate(root, jobRoot, candidate);
+                const input = z
+                    .object({
+                    candidateId: z.string().uuid(),
+                    review: z.record(z.unknown()),
+                    uncertainty: z.string().max(8000).default(''),
+                })
+                    .strict()
+                    .parse(request.input);
+                if (input.candidateId !== candidate.id)
+                    throw new Error('procedural_skill_candidate_changed');
+                const review = {
+                    ...input.review,
+                    render: candidate.captures.find((item) => item.view === 'hero')?.path ??
+                        candidate.captures[0].path,
+                    comparison: candidate.captures.find((item) => item.view === 'comparison')?.path,
+                    mapStrippedRender: candidate.captures.find((item) => item.view === 'map-stripped')
+                        ?.path,
+                };
+                const evidence = `candidates/${candidate.id}/review.json`;
+                await writeSharedFile(root, join(jobRoot, evidence), JSON.stringify({
+                    candidateId: candidate.id,
+                    sourceHash: candidate.sourceHash,
+                    specHash: candidate.specHash,
+                    review,
+                    uncertainty: input.uncertainty,
+                    sessionId: context.sessionId,
+                    operationId: binding.operation.operationId,
+                }, null, 2));
+                result = await adapter('host-receipt', {
+                    stepId: 'ai-review-recorded',
+                    evidence: [evidence],
+                    review,
+                });
+                const beforeSpecHash = candidate.expectedSpecHash;
+                candidate.expectedSpecHash = digest(await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json'));
+                run.receipts.push({
+                    action: 'ai-review-recorded',
+                    beforeSpecHash,
+                    afterSpecHash: candidate.expectedSpecHash,
+                    revision: run.revision,
+                });
+                candidate.review = {
+                    decision: input.review.action === 'continue' ? 'accept' : 'revise',
+                    findings: String(input.review.summary ?? ''),
+                    uncertainty: input.uncertainty,
+                    sourceHash: candidate.sourceHash,
+                };
+            }
+            else if (request.action === 'adopt') {
+                const input = z
+                    .object({ candidateId: z.string().uuid(), assetId: z.string() })
+                    .strict()
+                    .parse(request.input);
+                const status = await adapter('status');
+                if (!candidate ||
+                    candidate.id !== input.candidateId ||
+                    candidate.passId !== 'optimization-pass' ||
+                    status.currentStep !== 'emission-target')
+                    throw new Error('procedural_skill_final_candidate_required');
+                const adopted = await adoptCandidate(root, jobRoot, candidate, input.assetId);
+                candidate.adoptedPath = adopted.path;
+                const evidence = `candidates/${candidate.id}/adoption.json`;
+                await writeSharedFile(root, join(jobRoot, evidence), JSON.stringify(adopted));
+                await adapter('host-receipt', { stepId: 'emission-target', evidence: [evidence] });
+                result = adopted;
+                run.status = 'accepted';
+            }
+            else {
+                const metadataStep = request.action === 'request-correction' ||
+                    (request.action === 'run-step' &&
+                        [
+                            'tier1-diagnostics',
+                            'multi-angle-review',
+                            'pass-gate-check',
+                            'pipeline-sync',
+                        ].includes(String(request.input.stepId)));
+                if (request.action === 'request-correction' && !candidate)
+                    throw new Error('procedural_skill_candidate_missing');
+                if (metadataStep && candidate)
+                    await verifyCandidate(root, jobRoot, candidate);
+                const beforeSpecHash = candidate?.expectedSpecHash;
+                const beforeSpec = metadataStep && candidate
+                    ? JSON.parse((await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json')).toString('utf8'))
+                    : undefined;
+                let adapterInput = request.input;
+                if (request.action === 'run-step' &&
+                    ['tier1-diagnostics', 'multi-angle-review'].includes(String(request.input.stepId))) {
+                    if (!candidate)
+                        throw new Error('procedural_skill_candidate_missing');
+                    const parameters = request.input.parameters;
+                    if (parameters !== undefined &&
+                        (!parameters || typeof parameters !== 'object' || Object.keys(parameters).length))
+                        throw new Error('procedural_skill_diagnostics_use_current_capture');
+                    const paths = new Map();
+                    for (const capture of candidate.captures) {
+                        const path = `host-evidence/${candidate.id}/${capture.view}.png`;
+                        await writeSharedFile(root, join(jobRoot, 'workspace', path), await checkedFile(jobRoot, capture.path));
+                        paths.set(capture.view, path);
+                    }
+                    adapterInput = {
+                        stepId: request.input.stepId,
+                        parameters: request.input.stepId === 'tier1-diagnostics'
+                            ? {
+                                render: paths.get('hero'),
+                                mapStrippedRender: paths.get('map-stripped'),
+                                ...(candidate.hostReview
+                                    ? {
+                                        diagnosticBinding: {
+                                            schemaVersion: 1,
+                                            runId,
+                                            candidateId: candidate.id,
+                                            sourceHash: candidate.sourceHash,
+                                            specHash: candidate.specHash,
+                                            referenceHash: run.referenceHash,
+                                            renderHash: candidate.captures.find((capture) => capture.view === 'hero').hash,
+                                            view: 'hero',
+                                            reviewProfileHash: candidate.hostReview.profileHash,
+                                            renderReceiptPath: candidate.renderReceipt.path,
+                                            renderReceiptHash: candidate.renderReceipt.hash,
+                                        },
+                                    }
+                                    : {}),
+                            }
+                            : {
+                                render: paths.get('hero'),
+                                orbit: candidate.views
+                                    .filter((view) => view !== 'hero')
+                                    .map((view) => paths.get(view)),
+                            },
+                    };
+                }
+                result = await adapter(request.action, adapterInput);
+                if (metadataStep && candidate) {
+                    await verifyFiles(join(jobRoot, 'workspace'), candidateWorkspaceFiles(candidate));
+                    const currentSpec = await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json');
+                    verifyControlledSpecChange(beforeSpec, JSON.parse(currentSpec.toString('utf8')), request.action === 'request-correction'
+                        ? request.action
+                        : String(request.input.stepId), request.input.kind);
+                    candidate.expectedSpecHash = digest(currentSpec);
+                    run.receipts.push({
+                        action: request.action === 'request-correction'
+                            ? request.action
+                            : String(request.input.stepId),
+                        beforeSpecHash,
+                        afterSpecHash: candidate.expectedSpecHash,
+                        revision: run.revision,
+                    });
+                }
+            }
+            await current();
+            const diagnosticFailure = result && typeof result === 'object' && 'diagnosticFailure' in result
+                ? result.diagnosticFailure
+                : undefined;
+            if (run.status !== 'accepted')
+                run.status = diagnosticFailure ? 'needs-correction' : 'prepared';
+            run.lastError = undefined;
+            run.lastReportPath = undefined;
+            await saveGuards(run);
+            await writeControlJson(controlPath, run);
+            return {
+                runId,
+                revision: run.revision,
+                jobRoot,
+                candidate: run.candidates.at(-1),
+                result,
+                ...(descriptor.hostProtocolVersion === 2 ? { referenceHash: run.referenceHash } : {}),
+            };
+        }
+        catch (error) {
+            // A failed adapter may have committed only part of an upstream transition. Preserve the
+            // last verified state hashes; never bless its new bytes merely because the process exited.
+            run.status = signal.aborted ? 'uncertain' : 'needs-input';
+            run.lastError = error instanceof Error ? error.message : 'procedural_skill_failed';
+            run.lastReportPath = error instanceof ProductionSkillFailure ? error.reportPath : undefined;
+            await writeControlJson(controlPath, run);
+            throw error;
+        }
+    });
+}