@playcraft/cli 0.1.23 → 0.1.24

package/dist/auth/account-activation.js

@@ -1,157 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { loadGlobalConfig } from '../config.js';
-import { accountActivationMessage } from './messages.js';
-export const ACCOUNT_PENDING_ACTIVATION = 'account_pending_activation';
-export class AccountActivationError extends Error {
-    code;
-    status;
-    retryable = false;
-    constructor(code, message, status) {
-        super(message);
-        this.code = code;
-        this.status = status;
-        this.name = 'AccountActivationError';
-    }
-}
-export function responseErrorCode(payload) {
-    if (!payload || typeof payload !== 'object')
-        return undefined;
-    const { error, code } = payload;
-    return typeof error?.code === 'string' ? error.code : typeof code === 'string' ? code : undefined;
-}
-export function pendingAccountActivationError(status, payload) {
-    return status === 403 && responseErrorCode(payload) === ACCOUNT_PENDING_ACTIVATION
-        ? new AccountActivationError(ACCOUNT_PENDING_ACTIVATION, `${ACCOUNT_PENDING_ACTIVATION}: ${accountActivationMessage('pending')}`, status)
-        : undefined;
-}
-export function parseErrorPayload(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}
-function localActivationConfig() {
-    for (const path of [
-        join(process.cwd(), '.playcraft.json'),
-        '/project/.playcraft.json',
-        join(homedir(), '.playcraft.json'),
-    ]) {
-        if (!existsSync(path))
-            continue;
-        try {
-            const config = JSON.parse(readFileSync(path, 'utf8'));
-            if (config && typeof config === 'object' && !Array.isArray(config))
-                return config;
-        }
-        catch {
-            // Follow the existing local credential lookup when a file is unreadable.
-        }
-    }
-    return {};
-}
-function stringValue(value) {
-    return typeof value === 'string' && value ? value : undefined;
-}
-function activationBaseUrl(raw) {
-    try {
-        const url = new URL(raw);
-        if (!['http:', 'https:'].includes(url.protocol) ||
-            url.username ||
-            url.password ||
-            url.search ||
-            url.hash)
-            throw new Error();
-        url.pathname = url.pathname.replace(/\/+$/, '').replace(/\/api$/, '');
-        return url.toString().replace(/\/+$/, '');
-    }
-    catch {
-        throw new AccountActivationError('INVALID_ACTIVATION_TARGET', accountActivationMessage('invalidTarget'));
-    }
-}
-function savedTokenForTarget(config, rawUrl, target, environment) {
-    if (!rawUrl || (stringValue(config.env)?.trim() || '') !== environment)
-        return undefined;
-    try {
-        return activationBaseUrl(rawUrl) === target ? stringValue(config.token) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function normalizedSavedUrl(raw) {
-    try {
-        return raw ? activationBaseUrl(raw) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function activateAccount(options, defaultBaseUrl) {
-    const local = localActivationConfig();
-    const global = loadGlobalConfig();
-    const localUrl = stringValue(local.apiUrl);
-    const globalUrl = stringValue(global.backendUrl) || stringValue(global.url);
-    const explicitUrl = options.url || process.env.PLAYCRAFT_API_URL || process.env.PLAYCRAFT_URL;
-    const target = activationBaseUrl(explicitUrl || localUrl || globalUrl || defaultBaseUrl);
-    const explicitToken = options.token || process.env.PLAYCRAFT_TOKEN || process.env.PLAYCRAFT_SANDBOX_TOKEN;
-    const savedUrls = [normalizedSavedUrl(localUrl), normalizedSavedUrl(globalUrl)].filter(Boolean);
-    const savedTokens = [stringValue(local.token), stringValue(global.token)].filter(Boolean);
-    const environmentsConflict = savedUrls.length === 2 &&
-        savedUrls[0] === savedUrls[1] &&
-        (stringValue(local.env)?.trim() || '') !== (stringValue(global.env)?.trim() || '');
-    const environmentTokensConflict = process.env.PLAYCRAFT_TOKEN &&
-        process.env.PLAYCRAFT_SANDBOX_TOKEN &&
-        process.env.PLAYCRAFT_TOKEN !== process.env.PLAYCRAFT_SANDBOX_TOKEN;
-    const environmentUrlsConflict = process.env.PLAYCRAFT_API_URL &&
-        process.env.PLAYCRAFT_URL &&
-        normalizedSavedUrl(process.env.PLAYCRAFT_API_URL) !==
-            normalizedSavedUrl(process.env.PLAYCRAFT_URL);
-    if ((!explicitUrl && new Set(savedUrls).size > 1) ||
-        (!explicitToken && new Set(savedTokens).size > 1) ||
-        (environmentsConflict && !process.env.PLAYCRAFT_ENV) ||
-        (environmentTokensConflict && !options.token) ||
-        (environmentUrlsConflict && !options.url)) {
-        throw new AccountActivationError('AMBIGUOUS_ACTIVATION_TARGET', accountActivationMessage('ambiguous'));
-    }
-    const environment = (process.env.PLAYCRAFT_ENV ||
-        (!explicitUrl ? (localUrl ? stringValue(local.env) : stringValue(global.env)) : '') ||
-        '').trim();
-    const token = explicitToken ||
-        savedTokenForTarget(local, localUrl, target, environment) ||
-        savedTokenForTarget(global, globalUrl, target, environment);
-    if (!token)
-        throw new AccountActivationError('AUTH_REQUIRED', accountActivationMessage('missingToken'));
-    if (!/^playcraft_pat_[A-Za-z0-9_-]{32}$/.test(token)) {
-        throw new AccountActivationError('INVALID_ACTIVATION_TOKEN', accountActivationMessage('invalidToken'));
-    }
-    let response;
-    try {
-        response = await fetch(`${target}/api/settings/personal-access-tokens/activate`, {
-            method: 'POST',
-            redirect: 'error',
-            signal: AbortSignal.timeout(30_000),
-            headers: {
-                Authorization: `Bearer ${token}`,
-                ...(environment ? { 'playcraft-env': environment } : {}),
-            },
-        });
-    }
-    catch {
-        throw new AccountActivationError('ACTIVATION_UNCONFIRMED', accountActivationMessage('unavailable'));
-    }
-    if (!response.ok) {
-        await response.body?.cancel().catch(() => { });
-        throw new AccountActivationError('ACTIVATION_FAILED', accountActivationMessage('failed'), response.status);
-    }
-    const result = await response.json().catch(() => undefined);
-    if (!result ||
-        typeof result !== 'object' ||
-        result.accountStatus !== 'active') {
-        throw new AccountActivationError('ACTIVATION_UNCONFIRMED', accountActivationMessage('unavailable'), response.status);
-    }
-    console.log(accountActivationMessage('success'));
-}

package/dist/auth/messages.js

@@ -1,30 +0,0 @@
-const messages = {
-    en: {
-        activateOption: 'Explicitly activate the account using the current personal access token',
-        tokenOption: 'Personal access token for --activate (or use PLAYCRAFT_TOKEN)',
-        pending: 'Account activation is required. Run `playcraft login --activate` with the same token and target environment, then rerun your command.',
-        success: 'Account activated. Rerun your original command to continue.',
-        missingToken: 'No personal access token matches this target environment. Provide PLAYCRAFT_TOKEN or log in to this environment first.',
-        invalidToken: 'Account activation requires a personal access token. A sandbox token cannot activate an account.',
-        ambiguous: 'Activation credentials or target environments conflict. Specify --url, PLAYCRAFT_ENV when needed, and an explicit personal access token using --token or PLAYCRAFT_TOKEN.',
-        invalidTarget: 'Use a web service base address (http:// or https://) without credentials, a query, or a fragment.',
-        failed: 'Account activation failed. Check the target environment and token before trying again.',
-        unavailable: 'Account activation could not be confirmed. Check your account status before explicitly trying again.',
-    },
-    zh: {
-        activateOption: '明确使用当前个人访问令牌激活账号',
-        tokenOption: '用于 --activate 的个人访问令牌（也可使用 PLAYCRAFT_TOKEN）',
-        pending: '账号需要激活。请使用同一令牌和目标环境主动运行 `playcraft login --activate`，然后重新执行原命令。',
-        success: '账号已激活，请重新执行原命令继续。',
-        missingToken: '没有与目标环境匹配的个人访问令牌。请提供 PLAYCRAFT_TOKEN，或先登录此环境。',
-        invalidToken: '激活账号需要个人访问令牌，沙箱令牌不能用于激活账号。',
-        ambiguous: '激活凭据或目标环境存在冲突。请明确指定 --url、所需的 PLAYCRAFT_ENV，并通过 --token 或 PLAYCRAFT_TOKEN 提供个人访问令牌。',
-        invalidTarget: '激活目标必须是网页服务基址（http:// 或 https://），不能包含凭据、查询参数或片段。',
-        failed: '账号激活失败，请检查目标环境和令牌后再尝试。',
-        unavailable: '无法确认账号是否已激活。请先检查账号状态，再主动决定是否重试。',
-    },
-};
-export function accountActivationMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}

package/dist/commands/platform-skills.generated.js

@@ -1,19 +0,0 @@
-// 此文件由 scripts/generate-platform-skills.mjs 生成，请勿手改。
-// 重新生成：pnpm --filter @playcraft/cli generate:platform-skills
-/** `@playcraft/skills/playcraft-skills/` 下的 Platform Skill 目录名。 */
-export const PLATFORM_SKILL_DIRS = [
-    'playcraft-3d-flip-sprite',
-    'playcraft-asset-management',
-    'playcraft-build',
-    'playcraft-code-editor',
-    'playcraft-create-remix',
-    'playcraft-deploy',
-    'playcraft-iteration-methodology',
-    'playcraft-platform-intro',
-    'playcraft-prefab',
-    'playcraft-project-management',
-    'playcraft-remix-workflow',
-    'playcraft-save',
-    'playcraft-template-upgrade-merge',
-    'sound-effects',
-];

package/dist/commands/tools-batch.js

@@ -1,59 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { batchCreateSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { AgentApiClient } from '../utils/agent-api-client.js';
-import { handleError } from './tools-utils.js';
-const messages = {
-    en: {
-        create: 'Create a batch draft; confirm the whole batch in the browser',
-        input: 'Path to the batch draft JSON (JavaScript Object Notation, 数据交换格式) file',
-        status: 'Read a batch draft and its generation status',
-        id: 'Batch identifier',
-        created: 'Batch draft created',
-        help: '\nDraft shape: { clientRequestId, title, commonGoal, sourceWorkspaceId, engine, variants: [{ variantId, name, changes, preserves }] }\nUse the current workspace identifier as sourceWorkspaceId and a stable clientRequestId for retries. Maximum 10 variants. Confirm the batch in the browser.\n',
-        confirmation: 'Review the baseline and differences, then approve the whole batch in the browser.',
-    },
-    zh: {
-        create: '创建批次草案；整批确认须在浏览器完成',
-        input: '批次草案 JSON (JavaScript Object Notation, 数据交换格式) 文件路径',
-        status: '查询批次草案及生成状态',
-        id: '批次标识',
-        created: '批次草案已创建',
-        help: '\n草案格式：{ clientRequestId, title, commonGoal, sourceWorkspaceId, engine, variants: [{ variantId, name, changes, preserves }] }\nsourceWorkspaceId 填当前 workspace 标识，重试使用稳定的 clientRequestId。最多 10 个变体，整批在浏览器确认。\n',
-        confirmation: '请在浏览器查看基准和差异清单，然后确认整批。',
-    },
-};
-const language = () => /^zh/i.test(process.env.PLAYCRAFT_LANG ?? process.env.LANG ?? '') ? messages.zh : messages.en;
-export async function createBatchDraft(path, client = new AgentApiClient()) {
-    const draft = batchCreateSchema.parse(JSON.parse(await readFile(path, 'utf8')));
-    return client.post('/create-batch', draft);
-}
-export function registerBatchCommands(tools) {
-    const t = language();
-    tools.command('create-batch')
-        .description(t.create)
-        .requiredOption('--input <path>', t.input)
-        .option('--json', 'JSON (JavaScript Object Notation, 数据交换格式)')
-        .addHelpText('after', t.help)
-        .action(async (opts) => {
-        try {
-            const result = await createBatchDraft(opts.input);
-            console.log(opts.json ? JSON.stringify(result, null, 2) : `${t.created}: ${result.batchId}\n${t.confirmation}`);
-        }
-        catch (error) {
-            handleError(error);
-        }
-    });
-    tools.command('get-batch')
-        .description(t.status)
-        .requiredOption('--batch-id <id>', t.id)
-        .action(async (opts) => {
-        try {
-            const client = new AgentApiClient();
-            const result = await client.get('/get-batch', { batchId: opts.batchId });
-            console.log(JSON.stringify(result, null, 2));
-        }
-        catch (error) {
-            handleError(error);
-        }
-    });
-}

package/dist/commands/workspace-runtime.js

@@ -1,54 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { INCOMPATIBLE_EXIT_CODE, parseSandboxRuntimeConfig, } from '@playcraft/common/cloud-workspace/runtime';
-import { startWorkspaceRuntime } from '../workspace-runtime/serve.js';
-export async function runWorkspaceRuntimeServe(configPath) {
-    process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
-    let config;
-    try {
-        config = parseSandboxRuntimeConfig(JSON.parse(await readFile(configPath, 'utf8')));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`workspace-runtime config invalid: ${message}`);
-        process.exitCode = INCOMPATIBLE_EXIT_CODE;
-        return;
-    }
-    try {
-        const runtime = await startWorkspaceRuntime(config, { configPath });
-        console.log(JSON.stringify({
-            status: 'listening',
-            url: runtime.url,
-            phase: 'awaiting_native',
-            protocolMajor: runtime.config.protocolMajor,
-            protocolMinor: runtime.config.protocolMinor,
-        }));
-        await new Promise((resolve) => {
-            const stop = () => {
-                void runtime.close().finally(resolve);
-            };
-            process.once('SIGINT', stop);
-            process.once('SIGTERM', stop);
-        });
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === 'protocol_incompatible' || code === 'duplicate_instance') {
-            console.error(error instanceof Error ? error.message : code);
-            process.exitCode = INCOMPATIBLE_EXIT_CODE;
-            return;
-        }
-        throw error;
-    }
-}
-export function registerWorkspaceRuntimeCommands(program) {
-    const workspaceRuntime = program
-        .command('workspace-runtime')
-        .description('沙箱内 Sandbox Agent Server（Cloud Workspace 常驻运行入口）');
-    workspaceRuntime
-        .command('serve')
-        .description('前台常驻：读取 Runtime Server 下发的配置，不启动本地 backend 或旧同步')
-        .requiredOption('--config <path>', 'Runtime 引导配置 JSON')
-        .action(async (options) => {
-        await runWorkspaceRuntimeServe(options.config);
-    });
-}

package/dist/project-skills/commands.js

@@ -1,72 +0,0 @@
-import { verifyLocalProjectSkills } from './validation.js';
-export { verifyLocalProjectSkills } from './validation.js';
-import { downloadLocalProjectSkillArtifacts } from './remote-cache.js';
-import { resolve } from 'node:path';
-import { inspectProjectSkills, } from '@playcraft/common/project-skills';
-import { syncLocalProjectSkills, enableLocalProjectSkill, installFrozenProjectSkills, explainLocalProjectSkills } from './local-store.js';
-import { runLocalProjectSkills, localProjectSkillUsage } from './local-run.js';
-import { projectSkillsMessage as t } from './messages.js';
-import { reconcileLocalProjectSkills } from './reconcile.js';
-export async function inspectLocalProjectSkills(directory) {
-    const inventory = await inspectProjectSkills(directory);
-    // Report metadata only; never print complete skill bytes or project test data.
-    return { declaration: inventory.declaration, discovered: inventory.discovered, issues: inventory.issues,
-        sources: inventory.sources.map((source) => ({ entryKey: source.entryKey, root: source.root,
-            sourceTreeHash: source.sourceTreeHash, files: source.files.map((file) => file.path) })) };
-}
-export function registerProjectSkillsCommands(skills) {
-    const project = skills.command('project').description(t('description'));
-    const output = async (action) => {
-        try {
-            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.exitCode = 1;
-        }
-    };
-    project.command('run <prompt>').description(t('run')).requiredOption('--model <provider/model>', t('model'))
-        .option('--dir <path>', t('directory'), '.').action((prompt, options) => output(async () => {
-        const result = await runLocalProjectSkills(resolve(options.dir), { prompt, model: options.model });
-        if (result.exitCode !== 0)
-            process.exitCode = result.exitCode;
-        return result;
-    }));
-    project.command('usage').description(t('usage')).option('--dir <path>', t('directory'), '.')
-        .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('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'), '.')
-        .option('--online', t('online')).action((options) => output(async () => {
-        const directory = resolve(options.dir);
-        if (options.online)
-            await downloadLocalProjectSkillArtifacts(directory);
-        return installFrozenProjectSkills(directory);
-    }));
-    for (const enabled of [true, false])
-        project.command(enabled ? 'enable <entryKey>' : 'disable <entryKey>')
-            .description(t(enabled ? 'enable' : 'disable')).option('--dir <path>', t('directory'), '.')
-            .action((entryKey, options) => output(() => enableLocalProjectSkill(resolve(options.dir), entryKey, enabled)));
-    project.command('explain').description(t('explain')).option('--dir <path>', t('directory'), '.')
-        .action((options) => output(() => explainLocalProjectSkills(resolve(options.dir))));
-    project.command('inspect').description(t('inspect')).option('--dir <path>', t('directory'), '.')
-        .action(async (options) => {
-        const result = await inspectLocalProjectSkills(resolve(options.dir));
-        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        if (result.issues.length)
-            process.exitCode = 1;
-    });
-    project.command('verify').description(t('verify')).option('--dir <path>', t('directory'), '.')
-        .option('--json', t('json')).action(async (options) => {
-        try {
-            const result = await verifyLocalProjectSkills(resolve(options.dir));
-            process.stdout.write(`${options.json ? JSON.stringify(result) : t('verified')}\n`);
-        }
-        catch (error) {
-            process.stderr.write(`${t('failed')}: ${error instanceof Error ? error.message : String(error)}\n`);
-            process.exitCode = 1;
-        }
-    });
-}

package/dist/project-skills/lifecycle.js

@@ -1,28 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { readProjectSkillsLockFile } from '@playcraft/common/project-skills';
-import { syncLocalProjectSkills, readLocalProjectSkillSnapshot, installFrozenProjectSkills } from './local-store.js';
-import { verifyLocalProjectSkills } from './validation.js';
-import { projectSkillsMessage as t } from './messages.js';
-/** Existing formats keep their legacy consumer; format 3 never silently downgrades. */
-export async function prepareLocalSkillLifecycle(directory, action, cache) {
-    const raw = await readProjectSkillsLockFile(directory);
-    const managed = raw !== null && JSON.parse(raw).lockVersion === 3;
-    if (!managed && process.env.PROJECT_SKILLS_ADOPTION_ENABLED !== 'true')
-        return { managed: false };
-    if (raw !== null && !managed)
-        return { managed: false, legacy: true };
-    if (action === 'create' || action === 'push' || !managed)
-        await syncLocalProjectSkills(directory, cache);
-    await verifyLocalProjectSkills(directory);
-    const snapshot = await readLocalProjectSkillSnapshot(directory);
-    if (action === 'push') {
-        const paths = ['.playcraft/skills.json', '.playcraft/skills.lock.json', ...snapshot.declaration.entries.flatMap(entry => entry.source.kind === 'repository' ? [entry.source.root, ...(entry.projectFiles ?? [])] : [])];
-        const status = spawnSync('git', ['status', '--porcelain', '--', ...paths], { cwd: directory, encoding: 'utf8' });
-        if (status.status !== 0 || status.stdout.trim())
-            throw new Error(t('commitRequired'));
-    }
-    // Source-only checkouts work offline. Registry packages remain exact and require an authorized cache fill.
-    if (!snapshot.lock.entries.some(entry => entry.revision.kind === 'release'))
-        await installFrozenProjectSkills(directory, cache);
-    return { managed: true, declarationHash: snapshot.lock.declarationHash };
-}

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

@@ -1,112 +0,0 @@
-import { spawn, execFileSync } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { createRequire } from 'node:module';
-import { readFile, writeFile, mkdir, readdir, realpath } from 'node:fs/promises';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { createInterface } from 'node:readline';
-import { effectiveProjectSkills, readManagedSkillEvidence } from '@playcraft/common/project-skills';
-import { installFrozenProjectSkills, readLocalProjectSkillSnapshot, projectSkillsCache } from './local-store.js';
-import { verifyLocalProjectSkills } from './validation.js';
-import { projectSkillsMessage as t } from './messages.js';
-const require = createRequire(import.meta.url);
-export async function localProjectSkillUsage(directory, cache = projectSkillsCache()) {
-    const root = join(cache, 'usage', createHash('sha256').update(await realpath(directory)).digest('hex'));
-    let files;
-    try {
-        files = await readdir(root);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    return Promise.all(files.filter(file => /^[a-f0-9-]+\.json$/.test(file)).sort().map(async (file) => JSON.parse(await readFile(join(root, file), 'utf8'))));
-}
-/** Local evidence is explicitly client-reported; it never acts as a server evaluation or access grant. */
-export async function runLocalProjectSkills(directory, options, cache = projectSkillsCache()) {
-    if (execFileSync('opencode', ['--version'], { encoding: 'utf8', timeout: 10000 }).trim() !== '1.18.31')
-        throw new Error(t('runner'));
-    const cwd = await realpath(directory);
-    await verifyLocalProjectSkills(cwd);
-    const snapshot = await readLocalProjectSkillSnapshot(cwd);
-    const installed = await installFrozenProjectSkills(cwd, cache);
-    const runId = randomUUID(), runtimeRoot = join(installed.generation, '.runtime');
-    const home = join(runtimeRoot, 'home');
-    await mkdir(home, { recursive: true, mode: 0o700 });
-    const entries = await Promise.all(effectiveProjectSkills(snapshot.declaration, snapshot.lock, 'sandbox-agent').map(async (entry) => {
-        const bodyFile = join(installed.generation, entry.entryKey, 'SKILL.md');
-        return { name: entry.entryKey, skillRef: entry.revision.skillRef, revisionId: entry.revision.kind === 'source' ? entry.revision.sourceRevision : entry.revision.version,
-            artifactHash: entry.revision.artifactHash, bodyFile, bodyHash: createHash('sha256').update(await readFile(bodyFile)).digest('hex'), description: entry.revision.skillRef };
-    }));
-    await writeFile(join(runtimeRoot, 'manifest.json'), JSON.stringify({ schemaVersion: 1, runtimeId: runId, lockId: snapshot.lock.declarationHash, entries }), { mode: 0o400 });
-    await writeFile(join(runtimeRoot, 'opencode.json'), JSON.stringify({ model: options.model,
-        plugin: [pathToFileURL(require.resolve('@playcraft/common/project-skills/runtime-plugin')).href] }), { mode: 0o400 });
-    const usageRoot = join(cache, 'usage', createHash('sha256').update(cwd).digest('hex'));
-    await mkdir(usageRoot, { recursive: true, mode: 0o700 });
-    const evidence = new Map();
-    const report = { schemaVersion: 1, runId, declarationHash: snapshot.lock.declarationHash, provenance: 'local-client-reported',
-        runnerVersion: '1.18.31', model: options.model, startedAt: new Date().toISOString(), status: 'running', collectionStatus: 'collecting', loaded: [] };
-    const reportPath = join(usageRoot, `${runId}.json`);
-    await writeFile(reportPath, JSON.stringify(report), { mode: 0o600 });
-    const environment = { ...process.env, HOME: home, XDG_CONFIG_HOME: join(home, '.config'), XDG_DATA_HOME: join(home, '.local/share'), XDG_STATE_HOME: join(home, '.local/state'), XDG_CACHE_HOME: join(home, '.cache'),
-        OPENCODE_CONFIG: join(runtimeRoot, 'opencode.json'), OPENCODE_CONFIG_DIR: join(runtimeRoot, 'config'),
-        OPENCODE_DISABLE_PROJECT_CONFIG: 'true', OPENCODE_DISABLE_CLAUDE_CODE: 'true', OPENCODE_DISABLE_DEFAULT_PLUGINS: 'true', OPENCODE_DISABLE_AUTOUPDATE: 'true',
-        PLAYCRAFT_SKILL_RUNTIME_FILE: join(runtimeRoot, 'manifest.json') };
-    delete environment.PLAYCRAFT_SKILL_RUNTIME_ROOT;
-    delete environment.OPENCODE_CONFIG_CONTENT;
-    let child;
-    let cancelled = false, killTimer;
-    const cancel = () => {
-        cancelled = true;
-        child?.kill('SIGTERM');
-        killTimer ??= setTimeout(() => child?.kill('SIGKILL'), 5000);
-        killTimer.unref();
-    };
-    process.once('SIGINT', cancel);
-    process.once('SIGTERM', cancel);
-    try {
-        child = spawn('opencode', ['run', '--format', 'json', '--model', options.model, '--', options.prompt], { cwd, env: environment, stdio: ['ignore', 'pipe', 'inherit'] });
-        // Resolve spawn failures so an early error cannot become an unhandled rejection while reading stdout.
-        const finished = new Promise(resolve => {
-            child.once('error', error => resolve({ code: 1, error }));
-            child.once('close', code => resolve({ code: code ?? 1 }));
-        });
-        const lines = createInterface({ input: child.stdout });
-        let partial = false;
-        for await (const line of lines) {
-            try {
-                const event = JSON.parse(line);
-                const parsed = readManagedSkillEvidence(event);
-                if (parsed?.runtimeId === runId && parsed.lockId === report.declarationHash && entries.some(entry => entry.revisionId === parsed.skillVersionId && entry.artifactHash === parsed.artifactHash && entry.bodyHash === parsed.bodyHash)) {
-                    evidence.set(parsed.dedupeKey, parsed);
-                    report.loaded = [...evidence.values()];
-                    await writeFile(reportPath, JSON.stringify(report), { mode: 0o600 });
-                }
-                if (event.type === 'text' && typeof event.part?.text === 'string')
-                    process.stderr.write(event.part.text);
-            }
-            catch {
-                partial = true;
-            }
-        }
-        const result = await finished;
-        if (result.error)
-            throw result.error;
-        const code = cancelled ? 130 : result.code;
-        report.status = cancelled ? 'cancelled' : code === 0 ? 'completed' : 'failed';
-        report.collectionStatus = code === 0 && !partial ? 'complete' : 'partial';
-        return { ...report, reportPath, exitCode: code };
-    }
-    finally {
-        if (killTimer)
-            clearTimeout(killTimer);
-        process.removeListener('SIGINT', cancel);
-        process.removeListener('SIGTERM', cancel);
-        if (report.status === 'running') {
-            report.status = 'failed';
-            report.collectionStatus = 'partial';
-        }
-        await writeFile(reportPath, JSON.stringify(report), { mode: 0o600 });
-    }
-}