@playcraft/cli 0.1.70 → 0.1.72

package/README.md

@@ -37,7 +37,26 @@ npx @playcraft/cli@latest workspace push
 
 ## ✨ 特性
 
-远程技能的上传、更新、发布、审核、查询与下载见 [技能注册表命令](./SKILLS_REGISTRY.md)。入口为 `playcraft skills registry`，复用已有登录；本地技能发现与项目技能命令保持原有语义。
+远程技能的上传、更新、发布、审核、查询与下载见 [技能注册表命令](./SKILLS_REGISTRY.md)。入口为 `playcraft skills registry`，复用已有登录。
+
+`skills match` 默认从当前身份有权访问的远端技能库推荐候选，不依赖本地安装目录；只查询名称、描述、触发词、标签、能力和引擎等元数据：
+
+```bash
+playcraft skills match --intent "military,merge,base-building,strategy,island,battle" --engine threejs --json > /tmp/skills-match.json
+playcraft skills prepare --from-match /tmp/skills-match.json --skills "<候选中的namespace/slug>" --json
+```
+
+选定后提交候选的精确版本标识和制品摘要，服务端复验权限并解析硬依赖；准备命令仅下载独立选择锁中的包，校验后冻结到 `.playcraft/skill-selections/<selectionId>/`。版本发布变化不会静默替换所选根版本；缺少可解析的依赖或有效图关系会明确失败，不改用其他引擎或最新版本。目录不进入 Git 或作品交付包，同一选择可离线复验复用。
+
+云端工程会话中，`prepare` 默认在下载校验完成后登记持久激活请求，返回 `activation_requested`、`executionReady: false`。当前回合保持原锁，正常结束后由平台在同一会话自动派发唯一后续回合；原生进程空闲后合并精确技能、生成新锁、重载技能并要求读取选定正文，继续原任务并保留已有修改，无需用户再次发送消息。沿用原模型、推理强度及不高于当前许可的权限。
+
+已启用且满足当前回合执行要求的相同精确技能返回 `already_active`，不重复接续；需要独占执行的技能若尚未获得本回合的明确授权，仍会安排独占后续回合。`--prepare-only` 可只下载，本地没有云端执行代理时仍返回 `prepared_requires_activation`。激活保留已有技能和版本，同引用不同修订或登记后项目锁变化时明确冲突，不静默升级。来源回合失败、取消、结果未知、工程改绑定、技能撤权或新用户回合已取代来源时，不重放任务。持久请求与固定操作编号支持断线恢复；声明与锁的中断写入通过私有事务收敛。
+
+运行程序公开 `skillActivationVersion: 1`。升级需一起发布 Runtime、Business 和沙箱命令行工具；旧程序缺少能力时明确拒绝自动接续。
+
+`skills search --query "<关键词>" --json` 与 `skills match --installed ...` 保留为当前项目锁中已启用技能的查询。只有本地 Atom 编写场景显式使用 `match --local` / `--skills-dir`；远端请求失败不会自动回退本地扫描。
+
+沙箱通过当前会话的受限回环代理访问 Runtime，再由 Business 处理技能权限和版本；用户访问令牌和对象存储凭据不会交给执行模型。本地命令复用 `playcraft login` 的环境，也支持 `--url`。上线须同时更新 Business、Runtime 与沙箱命令行工具；模板更新不会自动改写已有锁定的推荐技能正文。
 
 - 🚀 **本地开发隧道** - 在本地 IDE 编写代码，云端编辑器实时预览与热更新
 - 📦 **Playable Ads 打包** - 支持 10 个主流广告平台的一键打包

package/dist/cli-root-help.js

@@ -8,6 +8,7 @@ export function getCliTopicsHelpText() {
         '  素材库     library list/search/facets/get/files/download',
         '  生成任务   assets estimate/generate/tasks/get/wait/cancel/download | assets animation',
         '  Remix 参考 references list/search/import（发现参考并读取当前工程中的固定快照）',
+        '             references prepare-starter-template（准备默认起始模板）',
         '  视频理解   video models | video understand | video jobs get/cancel',
         '  平台       build, build-base, build-playable, build-all, analyze, inspect, upgrade',
         '             tools 除 generate-* 外（Git / 沙箱构建 / 发布 / 列表 / Prefab 等，需后端 API）',

package/dist/commands/references.js

@@ -20,6 +20,8 @@ export function registerReferenceCommands(program) {
             const output = { schemaVersion: 'playcraft.references.v1', command: `references.${action}`, ...result };
             if (options.json)
                 console.log(JSON.stringify(output));
+            else if (action === 'prepare-starter-template')
+                console.log(result.path);
             else if (action === 'import') {
                 const reference = result.reference;
                 console.log(`${reference.name}\n${reference.resolvedPath}`);
@@ -43,6 +45,7 @@ export function registerReferenceCommands(program) {
     const scope = (command) => command.option('--workspace <id>', message('workspace'))
         .option('--directory <name>', message('directory')).option('--json', message('json'));
     scope(references.command('list').description(message('list'))).action(options => run('list', options));
+    scope(references.command('prepare-starter-template').description(message('prepareStarterTemplate'))).action(options => run('prepare-starter-template', options));
     scope(references.command('search [query]').description(message('search'))
         .option('--source <source>', message('source'), 'recommended')
         .option('--tag <value>', message('tag'), (value, previous) => [...previous, value], [])

package/dist/commands/skills.js

@@ -19,6 +19,11 @@
  *   4. <CLI 自身>/../../skills/playcraft-skills（monorepo 开发时，兼容旧路径 skills）
  */
 import { registerProjectSkillsCommands } from '../project-skills/commands.js';
+import { matchRemoteSkills, registerRemoteSkillPrepareCommand } from '../project-skills/remote-commands.js';
+import { readLockedProjectSkillCatalog } from '../project-skills/discovery.js';
+import { findManagedSkillsRoot, filterLockedSkillsByEngine, normalizeSkillEngine, rankLockedProjectSkills } from '../project-skills/search.js';
+import { registerSkillSearchCommand, printLockedSkillSearch, printSkillSearchError } from '../project-skills/search-command.js';
+import { projectSkillsMessage as projectSkillMessage } from '../project-skills/messages.js';
 import { registerRegistryCommands } from '../skill-registry/commands.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -1433,6 +1438,8 @@ export function registerSkillsCommands(program) {
         .command('skills')
         .description('开发时 Skill 发现与脚手架工具（按 engine/intent 推荐 skill 集合，或将 ref 文件复制到项目）');
     registerProjectSkillsCommands(skills);
+    registerRemoteSkillPrepareCommand(skills);
+    registerSkillSearchCommand(skills);
     registerRegistryCommands(skills);
     // 公共选项：skills 目录
     const addSkillsDirOption = (cmd) => cmd.option('--skills-dir <path>', '指定 skills 目录路径（默认自动发现）');
@@ -1487,11 +1494,68 @@ export function registerSkillsCommands(program) {
     // ── match ─────────────────────────────────────────────────────────────────
     addSkillsDirOption(skills
         .command('match')
-        .description('按 intent 推荐完整 skill 集合（含依赖与 scaffold）；省略 --engine 时自动从 intent 推断引擎')
-        .option('--engine <name>', '目标引擎（threejs / phaser）；省略则由 --intent 自动推断')
-        .option('--intent <tags>', '意图关键词，逗号分隔（如 board,3d,path,animation）', '')
+        .description(projectSkillMessage('remoteMatch'))
+        .option('--engine <name>', projectSkillMessage('remoteEngine'))
+        .option('--intent <tags>', projectSkillMessage('remoteIntent'), '')
+        .option('--dir <path>', projectSkillMessage('directory'), '.')
+        .option('--limit <count>', projectSkillMessage('searchLimit'), '20')
+        .option('--url <url>', projectSkillMessage('remoteUrl'))
+        .option('--installed', projectSkillMessage('remoteInstalled'))
+        .option('--local', projectSkillMessage('remoteLocal'))
         .option('--json', '输出 JSON 格式')
-        .option('--verbose', '输出 scaffold 明细与完整媒体/命令提示')).action(async (opts) => {
+        .option('--verbose', projectSkillMessage('remoteVerbose'))).action(async (opts) => {
+        try {
+            if (!opts.installed && !opts.local && !opts.skillsDir) {
+                await matchRemoteSkills(opts);
+                return;
+            }
+            const root = await findManagedSkillsRoot(opts.dir);
+            if (root) {
+                if (opts.skillsDir)
+                    throw new Error(projectSkillMessage('searchManagedOverride'));
+                const catalog = await readLockedProjectSkillCatalog(root);
+                const engine = opts.engine ? normalizeSkillEngine(opts.engine) : undefined;
+                const intentTags = opts.intent.split(/[\s,，、]+/).map(tag => tag.trim()).filter(Boolean);
+                let entries = filterLockedSkillsByEngine(catalog.skills, engine).flatMap(skill => skill.manifest
+                    ? [{ atomId: skill.manifest.atomId, dir: skill.skillDir, manifest: skill.manifest }] : []);
+                let matched = engine
+                    ? buildMatchResult(entries, engine, intentTags, opts.intent)
+                    : buildAutoMatchResult(entries, intentTags, opts.intent);
+                if (!engine && matched.engine) {
+                    entries = filterLockedSkillsByEngine(catalog.skills, matched.engine).flatMap(skill => skill.manifest
+                        ? [{ atomId: skill.manifest.atomId, dir: skill.skillDir, manifest: skill.manifest }] : []);
+                    matched = { ...matched, ...buildMatchResult(entries, matched.engine, intentTags, opts.intent), engineSource: 'inferred' };
+                }
+                const byAtom = new Map(catalog.skills.filter(skill => skill.manifest).map(skill => [skill.manifest.atomId, skill]));
+                const search = rankLockedProjectSkills(catalog.skills, { query: opts.intent, engine: engine ?? matched.engine ?? undefined });
+                const result = { ...matched, source: 'project-lock', lockHash: catalog.lockHash,
+                    // Legacy fusion edges are not relationships from this immutable lock.
+                    fusionHints: [],
+                    items: matched.items.map(item => {
+                        const skill = byAtom.get(item.atomId);
+                        return { ...item, entryKey: skill.entryKey, skillRef: skill.skillRef,
+                            revision: skill.revision, artifactHash: skill.artifactHash };
+                    }),
+                    skills: search.skills, totalSkills: search.total,
+                    diagnostics: entries.length ? [] : [projectSkillMessage('searchNoAtoms')] };
+                if (opts.json)
+                    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                else {
+                    if (entries.length)
+                        printMatchResult(result, !!opts.verbose, entries);
+                    for (const diagnostic of result.diagnostics)
+                        console.log(diagnostic);
+                    printLockedSkillSearch(search.skills, search.total);
+                }
+                return;
+            }
+            if (opts.installed)
+                throw new Error(projectSkillMessage('searchRequiresLock'));
+        }
+        catch (error) {
+            printSkillSearchError(error, opts.json);
+            return;
+        }
         const config = await loadConfig({}).catch(() => ({ skillsDir: undefined }));
         const dirs = resolveSkillsDirs(opts.skillsDir, config.skillsDir);
         if (dirs.length === 0) {

package/dist/commands/tools-batch.js

@@ -100,6 +100,8 @@ export function registerBatchCommands(tools) {
     tools.command('get-batch')
         .description(t.status)
         .requiredOption('--batch-id <id>', t.id)
+        // Output is always JSON; accept the flag so status reads match create-batch and sync-batch.
+        .option('--json', 'JSON (JavaScript Object Notation, 数据交换格式)')
         .action(async (opts) => {
         try {
             const client = new AgentApiClient();

package/dist/project-skills/discovery.js

@@ -0,0 +1,248 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, open, readFile, readdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { load } from 'js-yaml';
+import { canonicalProjectSkillsJson, createCanonicalBundleArchive, effectiveProjectSkills, extractBundleArchive, readProjectSkillSource, readProjectSkillsLockFile, sourceTreeDigest, validateProjectSkillsSnapshot, } from '@playcraft/common/project-skills';
+import { projectSkillsCache } from './local-store.js';
+import { ensureSharedDirectory, writeSharedFile } from '../workspace-runtime/workspaces/shared-write.js';
+/** Runtime availability is determined by the locked metadata, independent of unsynced source edits. */
+export async function readLockedProjectSkillSnapshot(root) {
+    const management = await lstat(join(root, '.playcraft'));
+    const declaration = join(root, '.playcraft/skills.json');
+    const stat = await lstat(declaration);
+    if (!management.isDirectory() || management.isSymbolicLink() || !stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+        throw new Error('workspace_skills_invalid');
+    return validateProjectSkillsSnapshot(await readFile(declaration, 'utf8'), await readProjectSkillsLockFile(root));
+}
+export async function ensureProjectSkillDirectory(root, path, reuseExisting = false) {
+    let current = root;
+    let missing = false;
+    for (const segment of path.split('/')) {
+        current = join(current, segment);
+        // Validate every existing segment before creating anything, so a link never redirects the tree.
+        const stat = await lstat(current).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
+            throw new Error('workspace_skills_invalid');
+        if (!stat)
+            missing = true;
+    }
+    if (reuseExisting && !missing)
+        return current;
+    await ensureSharedDirectory(root, current);
+    return current;
+}
+/** Cache misses may reconstruct only the exact locked repository bytes, never a newer source. */
+export async function readLockedProjectSkillFiles(root, cache, entry, view, loadArtifact, reuseExisting = false) {
+    const persistent = await ensureProjectSkillDirectory(root, '.playcraft/skill-artifacts', reuseExisting);
+    const saved = join(persistent, `${entry.revision.artifactHash}.tar.gz`);
+    const path = join(cache, `${entry.revision.artifactHash}.tar.gz`);
+    const contentHash = view.lock.lockVersion === 4 ? entry.revision.contentHash : undefined;
+    const contentSaved = contentHash ? join(persistent, `content-${contentHash}.tar.gz`) : undefined;
+    const contentPath = contentHash ? join(cache, `content-${contentHash}.tar.gz`) : undefined;
+    let archive;
+    let contentAddressed = false;
+    let persisted = false;
+    try {
+        const stat = await lstat(saved);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 80 * 1024 * 1024)
+            throw new Error('workspace_skills_invalid_bundle');
+        archive = await readFile(saved);
+        persisted = true;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        try {
+            if (!contentSaved)
+                throw error;
+            const stat = await lstat(contentSaved);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 80 * 1024 * 1024)
+                throw new Error('workspace_skills_invalid_bundle');
+            archive = await readFile(contentSaved);
+            contentAddressed = true;
+            persisted = true;
+        }
+        catch (cacheError) {
+            if (cacheError.code !== 'ENOENT')
+                throw cacheError;
+            try {
+                archive = await readFile(path);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                try {
+                    if (!contentPath)
+                        throw error;
+                    archive = await readFile(contentPath);
+                    contentAddressed = true;
+                }
+                catch (contentError) {
+                    if (contentError.code !== 'ENOENT')
+                        throw contentError;
+                    const declaration = view.declaration.entries.find(item => item.entryKey === entry.entryKey);
+                    if (entry.revision.kind === 'source' && declaration.source.kind === 'repository') {
+                        const source = await readProjectSkillSource(root, declaration);
+                        if (source.sourceTreeHash !== entry.sourceTreeHash)
+                            throw new Error('workspace_skills_source_changed');
+                        if (contentHash) {
+                            if (source.sourceTreeHash !== contentHash)
+                                throw new Error('workspace_skills_digest_mismatch');
+                            return source.files.map(file => ({ path: file.path, data: Buffer.from(file.content) }));
+                        }
+                        archive = createCanonicalBundleArchive(source.files.map(file => ({ path: file.path, data: Buffer.from(file.content) })));
+                    }
+                    else {
+                        if (!loadArtifact)
+                            throw new Error('workspace_skills_artifact_unavailable');
+                        archive = await loadArtifact(entry);
+                        contentAddressed = Boolean(contentHash);
+                    }
+                }
+            }
+        }
+    }
+    if (!contentAddressed && createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    const extracted = extractBundleArchive(archive);
+    if (extracted.issues.length)
+        throw new Error('workspace_skills_invalid_bundle');
+    if (contentHash && sourceTreeDigest(extracted.files.map(file => ({ path: file.path, content: file.data }))) !== contentHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    if (entry.revision.kind === 'source' && sourceTreeDigest(extracted.files.map(file => ({ path: file.path, content: file.data }))) !== entry.sourceTreeHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    if (!reuseExisting || !persisted)
+        await writeSharedFile(root, contentAddressed ? contentSaved : saved, archive);
+    return extracted.files;
+}
+export function projectSkillMetadata(entryKey, content) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+    const parsed = frontmatter ? load(frontmatter[1]) : {};
+    const data = parsed && typeof parsed === 'object' ? parsed : {};
+    return { entryKey, name: typeof data.name === 'string' ? data.name : entryKey,
+        description: typeof data.description === 'string' ? data.description : '', content };
+}
+/** Read-only task generation lives outside source discovery and is omitted from Git/snapshots. */
+async function freezeProjectSkillFiles(root, cache, loadArtifact, reuseExisting = false) {
+    const snapshot = await readLockedProjectSkillSnapshot(root);
+    const entries = effectiveProjectSkills(snapshot.declaration, snapshot.lock, 'sandbox-agent');
+    const base = await ensureProjectSkillDirectory(root, '.playcraft/skills', reuseExisting);
+    const lockHash = createHash('sha256').update(canonicalProjectSkillsJson(snapshot.lock)).digest('hex');
+    const generation = await ensureProjectSkillDirectory(base, lockHash, reuseExisting);
+    const skills = [];
+    const expectedFiles = new Set();
+    for (const entry of entries) {
+        const files = await readLockedProjectSkillFiles(root, cache, entry, snapshot, loadArtifact, reuseExisting);
+        for (const file of files) {
+            const target = join(generation, entry.entryKey, file.path);
+            const relative = join(entry.entryKey, file.path);
+            expectedFiles.add(relative);
+            await ensureProjectSkillDirectory(generation, dirname(relative), reuseExisting);
+            const existing = await lstat(target).catch((error) => {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                return undefined;
+            });
+            if (!existing)
+                await writeFile(target, file.data, { flag: 'wx', mode: 0o444 }).catch(error => {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                });
+            const handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const stat = await handle.stat();
+                if (!stat.isFile() || stat.nlink !== 1 || !file.data.equals(await handle.readFile()))
+                    throw new Error('workspace_skills_digest_mismatch');
+                // A private controller umask must not remove the developer's read access.
+                // An already shared read-only inode may belong to the controller rather than this reader.
+                // Repair only when needed, after verifying the bytes on the same open descriptor.
+                if ((stat.mode & 0o777) !== 0o444)
+                    await handle.chmod(0o444);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        skills.push({ entry, files, skillDir: join(generation, entry.entryKey),
+            path: join(generation, entry.entryKey, 'SKILL.md') });
+    }
+    const verifyTree = async (directory, relative = '') => {
+        for (const item of await readdir(directory, { withFileTypes: true })) {
+            const path = join(relative, item.name);
+            if (item.isSymbolicLink())
+                throw new Error('workspace_skills_invalid_bundle');
+            if (item.isDirectory()) {
+                if (![...expectedFiles].some(file => file.startsWith(`${path}/`)))
+                    throw new Error('workspace_skills_invalid_bundle');
+                await verifyTree(join(directory, item.name), path);
+            }
+            else if (!item.isFile() || !expectedFiles.has(path))
+                throw new Error('workspace_skills_invalid_bundle');
+        }
+    };
+    await verifyTree(generation);
+    return { snapshot, lockHash, skills };
+}
+/** Compatibility view used by native runners; discovery and execution share the same verified files. */
+export async function freezeLockedProjectSkills(root, cache, loadArtifact) {
+    const frozen = await freezeProjectSkillFiles(root, cache, loadArtifact);
+    return { declarationHash: frozen.snapshot.lock.declarationHash, lockHash: frozen.lockHash,
+        skills: frozen.skills.map(({ entry, files, path }) => {
+            const body = files.find(file => file.path === 'SKILL.md');
+            if (!body)
+                throw new Error('workspace_skills_body_missing');
+            const info = projectSkillMetadata(entry.entryKey, body.data.toString('utf8'));
+            return { name: info.name, description: info.description, skillRef: entry.revision.skillRef,
+                revision: entry.revision.kind === 'source' ? entry.revision.sourceRevision : entry.revision.version, path };
+        }) };
+}
+function metadataTerms(value) {
+    if (typeof value === 'string')
+        return value.split(/[,，、\n]+/).map(term => term.trim()).filter(Boolean);
+    if (Array.isArray(value))
+        return value.filter((term) => typeof term === 'string').map(term => term.trim()).filter(Boolean);
+    return [];
+}
+function atomManifest(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    const label = record.label && typeof record.label === 'object' ? record.label : undefined;
+    if (typeof record.atomId !== 'string' || !record.atomId.trim() || typeof record.category !== 'string'
+        || typeof label?.zh !== 'string' || typeof label.en !== 'string'
+        || !Array.isArray(record.tags) || record.tags.some(tag => typeof tag !== 'string'))
+        return undefined;
+    return value;
+}
+/** Searches only enabled sandbox skills from the validated project lock, never live source scans. */
+export async function readLockedProjectSkillCatalog(root, cache = projectSkillsCache(), loadArtifact) {
+    const frozen = await freezeProjectSkillFiles(root, cache, loadArtifact, true);
+    const skills = frozen.skills.map(({ entry, files, skillDir, path }) => {
+        const body = files.find(file => file.path === 'SKILL.md');
+        if (!body)
+            throw new Error('workspace_skills_body_missing');
+        const content = body.data.toString('utf8');
+        const info = projectSkillMetadata(entry.entryKey, content);
+        const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+        const parsed = frontmatter ? load(frontmatter[1]) : {};
+        const data = parsed && typeof parsed === 'object' ? parsed : {};
+        const manifestFile = files.find(file => file.path === 'manifest.json');
+        let manifest;
+        if (manifestFile) {
+            const value = JSON.parse(manifestFile.data.toString('utf8'));
+            manifest = atomManifest(value);
+        }
+        return { entryKey: entry.entryKey, skillRef: entry.revision.skillRef,
+            revision: entry.revision.kind === 'source' ? entry.revision.sourceRevision : entry.revision.version,
+            artifactHash: entry.revision.artifactHash, name: info.name, description: info.description,
+            triggers: metadataTerms(data.triggers), tags: [...new Set([...metadataTerms(data.tags), ...metadataTerms(manifest?.tags)])],
+            keywords: [...new Set([...metadataTerms(data.keywords), ...metadataTerms(manifest?.keywords)])],
+            ...(manifest ? { manifest } : {}), skillDir, path };
+    });
+    return { snapshot: frozen.snapshot, lockHash: frozen.lockHash, skills };
+}

package/dist/project-skills/messages.js

@@ -1,5 +1,45 @@
 const messages = {
     en: {
+        remoteMatch: 'Recommend accessible remote skill candidates by intent and engine; download only after exact selection',
+        remoteEngine: 'Filter by engine (threejs / phaser); omit to discover candidates across engines',
+        remoteIntent: 'Task intent, keywords or natural-language query',
+        remoteVerbose: 'Show scaffold details for explicitly local matching',
+        remoteUrl: 'Platform environment URL (defaults to the saved login environment)',
+        remoteUnavailable: 'The remote skill request did not complete. No local directory or different version was substituted.',
+        remoteAccessDenied: 'Remote skill access was denied. Check the current platform login or execution scope.',
+        remoteBridgeInvalid: 'The current execution skill bridge is invalid; refusing another identity or environment.',
+        remoteTooLarge: 'The remote skill response exceeds the allowed size',
+        remoteSelectionChanged: 'The selected exact skill revision does not match the remote preparation receipt',
+        remoteDigestMismatch: 'The downloaded skill does not match its locked artifact digest',
+        remoteInvalidEngine: 'The engine must be phaser or threejs',
+        remoteSource: 'Source: authorized remote skill registry candidates (not yet installed)',
+        remoteNoMatches: 'No accessible remote skill candidates match this query.',
+        remotePrepareHint: 'Save the --json match result, then use skills prepare --from-match <file> --skills <skillRef,...> to download chosen exact versions and dependencies.',
+        remoteInstalled: 'Search the current enabled project lock explicitly',
+        remoteLocal: 'Use local Atom authoring directories explicitly (no remote lookup)',
+        remotePrepare: 'Prepare exact candidates and dependencies; in a cloud session, activate them and continue automatically after this turn',
+        remotePrepareOnly: 'Download only; do not request activation or continuation',
+        remoteActivationRequested: 'Activation is queued. Finish this turn normally; the platform will load the exact selected skills and continue this task in the next turn. Do not execute the prepared copy or request another continuation.',
+        remoteAlreadyActive: 'These exact skills are already enabled in the current lock. Use its frozen paths; no additional turn was requested.',
+        remoteMatchFile: 'A saved JSON result from skills match',
+        remoteSelectedRefs: 'Comma-separated skillRef or skillRef@version values from that match result',
+        remoteInvalidMatchFile: 'Expected a regular match result file smaller than 4 MiB',
+        remoteInvalidSelection: 'Choose 1 to 50 unambiguous skill references from the saved match result',
+        remotePrepared: 'Selected exact skill bundles are prepared locally.',
+        remoteActivationRequired: 'This selection is prepared only. Automatic activation requires the current cloud execution bridge; the local preparation did not change the project or start a turn.',
+        search: 'Search enabled skills in the current project lock by name, description, triggers and tags',
+        searchQuery: 'Keywords or a natural-language query; omit to list enabled skills',
+        searchEngine: 'Filter declared engine compatibility (threejs / phaser)',
+        searchLimit: 'Maximum results, from 1 to 100',
+        searchInvalidLimit: 'The result limit must be an integer from 1 to 100',
+        searchRequiresLock: 'No project skill lock was found. In Cloud Workspace, open Skills management to configure skills. To discover platform candidates, use skills registry list --scope platform --query <text> --json; candidates must be explicitly added and locked before use.',
+        searchFailed: 'Skill search failed',
+        searchNoMatches: 'No enabled locked skills match this query.',
+        searchSummary: 'Matching locked skills:',
+        searchNoAtoms: 'This lock has no enabled Atom manifests. Search results below include ordinary skills; an empty Atom list does not mean no skills are available.',
+        searchLockedSource: 'Source: enabled project skills (exact locked revisions)',
+        searchManagedOverride: 'A managed project can only search its current skill lock; --skills-dir cannot override it.',
+        searchReadPath: 'Read the frozen SKILL.md at the returned path before using a skill.',
         migrateLockV4: 'Upgrade a v3 lock using verified original artifacts and retain a backup',
         migrationMissingArchive: 'Cannot upgrade: the exact locked artifact is missing',
         migrationInvalidArchive: 'Cannot upgrade: the locked artifact is invalid or changed',
@@ -45,6 +85,46 @@ const messages = {
         changed: 'Source files have changed since the saved revision',
     },
     zh: {
+        remoteMatch: '按意图和引擎推荐远端可访问技能候选，精确选定后再按需下载',
+        remoteEngine: '按引擎过滤（threejs / phaser）；省略时发现不同引擎的候选',
+        remoteIntent: '任务意图、关键词或自然语言查询',
+        remoteVerbose: '显式使用本地匹配时显示脚手架明细',
+        remoteUrl: '平台环境地址（默认使用已保存登录的环境）',
+        remoteUnavailable: '远端技能请求未完成；未改用本地目录或其他版本。',
+        remoteAccessDenied: '远端技能访问被拒绝，请检查平台登录或当前执行范围。',
+        remoteBridgeInvalid: '当前执行的技能代理配置无效，拒绝改用其他身份或环境。',
+        remoteTooLarge: '远端技能响应超出允许大小',
+        remoteSelectionChanged: '所选技能的精确修订与远端准备回执不一致',
+        remoteDigestMismatch: '下载的技能与锁定制品摘要不一致',
+        remoteInvalidEngine: '引擎必须是 phaser 或 threejs',
+        remoteSource: '来源：有权访问的远端技能候选（尚未安装）',
+        remoteNoMatches: '远端可访问技能中没有匹配此查询的候选。',
+        remotePrepareHint: '保存 --json 匹配结果，再用 skills prepare --from-match <文件> --skills <skillRef,...> 下载选定的精确版本及依赖。',
+        remoteInstalled: '显式检索当前项目锁中已启用的技能',
+        remoteLocal: '显式使用本地 Atom 编写目录，不查询远端',
+        remotePrepare: '下载选定精确版本及依赖；在云端会话中，本回合结束后自动激活并接续任务',
+        remotePrepareOnly: '只下载准备，不请求激活或任务接续',
+        remoteActivationRequested: '已登记激活请求。请正常结束本回合，平台将在下一回合加载选定的精确技能并继续原任务；不要执行准备副本或再次申请接续。',
+        remoteAlreadyActive: '这些精确技能已在当前锁中启用，请使用当前锁的冻结路径；未重复申请新回合。',
+        remoteMatchFile: 'skills match 保存的结构化结果文件',
+        remoteSelectedRefs: '匹配结果中的 skillRef 或 skillRef@version，多个用逗号分隔',
+        remoteInvalidMatchFile: '匹配结果须为小于 4 MiB 的普通文件',
+        remoteInvalidSelection: '请从匹配结果中选择 1 到 50 个无歧义的技能引用',
+        remotePrepared: '选定技能的精确制品已在本地准备完成。',
+        remoteActivationRequired: '此选择仅已准备。自动激活需要当前云端执行代理；本地准备未改写项目或启动回合。',
+        search: '按名称、描述、触发词和标签搜索当前项目锁中已启用的技能',
+        searchQuery: '关键词或自然语言查询；省略则列出已启用技能',
+        searchEngine: '按声明的引擎兼容性过滤（threejs / phaser）',
+        searchLimit: '最多返回条数，范围 1 到 100',
+        searchInvalidLimit: '返回条数必须是 1 到 100 的整数',
+        searchRequiresLock: '未找到项目技能锁。请在云工作区的技能管理中配置技能。发现平台候选可用 skills registry list --scope platform --query <text> --json；候选须显式加入项目并锁定后才能使用。',
+        searchFailed: '技能检索失败',
+        searchNoMatches: '当前锁中已启用的技能没有匹配此查询的结果。',
+        searchSummary: '匹配的锁定技能：',
+        searchNoAtoms: '当前锁没有已启用的 Atom manifest。下方搜索结果包含普通技能；Atom 列表为空不代表没有可用技能。',
+        searchLockedSource: '来源：项目已启用技能（精确锁定修订）',
+        searchManagedOverride: '受控项目只能检索当前技能锁，不能通过 --skills-dir 覆盖。',
+        searchReadPath: '使用技能前，请读取结果 path 指向的冻结 SKILL.md。',
         migrateLockV4: '使用已核验的原始技能包升级 v3 锁并保留备份',
         migrationMissingArchive: '无法升级：缺少锁定的原始技能包',
         migrationInvalidArchive: '无法升级：锁定的技能包无效或已更改',