kode-sdk 2.7.0

package/dist/infra/store.js

@@ -0,0 +1,584 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONStore = void 0;
+class JSONStore {
+    constructor(baseDir, flushIntervalMs = 50) {
+        this.baseDir = baseDir;
+        this.flushIntervalMs = flushIntervalMs;
+        this.eventWriters = new Map();
+        this.walQueue = new Map();
+        this.walRecovered = new Set();
+        // 启动时主动扫描并恢复所有 WAL
+        void this.recoverAllWALs();
+    }
+    // ========== 路径管理 ==========
+    getAgentDir(agentId) {
+        const path = require('path');
+        return path.join(this.baseDir, agentId);
+    }
+    getRuntimePath(agentId, file) {
+        const fs = require('fs');
+        const path = require('path');
+        const dir = path.join(this.baseDir, agentId, 'runtime');
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return path.join(dir, file);
+    }
+    getEventsPath(agentId, file) {
+        const fs = require('fs');
+        const path = require('path');
+        const dir = path.join(this.baseDir, agentId, 'events');
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return path.join(dir, file);
+    }
+    getHistoryDir(agentId, subdir) {
+        const fs = require('fs');
+        const path = require('path');
+        const dir = path.join(this.baseDir, agentId, 'history', subdir);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+    getSnapshotsDir(agentId) {
+        const fs = require('fs');
+        const path = require('path');
+        const dir = path.join(this.baseDir, agentId, 'snapshots');
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+    getMetaPath(agentId) {
+        const path = require('path');
+        return path.join(this.baseDir, agentId, 'meta.json');
+    }
+    // ========== 运行时状态管理（带 WAL） ==========
+    async saveMessages(agentId, messages) {
+        await this.saveWithWal(agentId, 'messages', messages);
+    }
+    async loadMessages(agentId) {
+        const raw = (await this.loadWithWal(agentId, 'messages')) || [];
+        if (!Array.isArray(raw))
+            return [];
+        const out = [];
+        for (const item of raw) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const role = item.role;
+            if (role !== 'system' && role !== 'user' && role !== 'assistant')
+                continue;
+            let content = item.content;
+            if (typeof content === 'string') {
+                content = [{ type: 'text', text: content }];
+            }
+            if (!Array.isArray(content))
+                content = [];
+            // Guard against sparse arrays getting serialized as `null` entries.
+            const cleaned = content.filter((block) => block && typeof block === 'object' && typeof block.type === 'string');
+            out.push({ ...item, role, content: cleaned });
+        }
+        return out;
+    }
+    async saveToolCallRecords(agentId, records) {
+        await this.saveWithWal(agentId, 'tool-calls', records);
+    }
+    async loadToolCallRecords(agentId) {
+        return await this.loadWithWal(agentId, 'tool-calls') || [];
+    }
+    async saveTodos(agentId, snapshot) {
+        const fs = require('fs').promises;
+        const path = this.getRuntimePath(agentId, 'todos.json');
+        await fs.writeFile(path, JSON.stringify(snapshot, null, 2), 'utf-8');
+    }
+    async loadTodos(agentId) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getRuntimePath(agentId, 'todos.json'), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // ========== Skills 状态管理 ==========
+    async saveSkillsState(agentId, state) {
+        const fs = require('fs').promises;
+        const path = this.getRuntimePath(agentId, 'skills.json');
+        await fs.writeFile(path, JSON.stringify(state, null, 2), 'utf-8');
+    }
+    async loadSkillsState(agentId) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getRuntimePath(agentId, 'skills.json'), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // ========== 统一的 WAL 读写策略 ==========
+    async saveWithWal(agentId, name, data) {
+        const fs = require('fs');
+        const fsp = fs.promises;
+        const path = this.getRuntimePath(agentId, `${name}.json`);
+        const walPath = this.getRuntimePath(agentId, `${name}.wal`);
+        // Serialize the entire WAL+main-file transaction per (agentId,name).
+        // Otherwise concurrent writes can race on the shared `${path}.tmp` and cause ENOENT on rename.
+        await this.queueWalWrite(agentId, name, async () => {
+            // 1. Write to WAL first
+            const walData = JSON.stringify({ data, timestamp: Date.now() });
+            await fsp.writeFile(walPath, walData, 'utf-8');
+            // 2. Write to main file (atomic: tmp + rename)
+            const tmp = `${path}.tmp`;
+            await fsp.writeFile(tmp, JSON.stringify(data, null, 2), 'utf-8');
+            await fsp.rename(tmp, path);
+            // 3. Remove WAL after successful write
+            if (fs.existsSync(walPath)) {
+                await fsp.unlink(walPath).catch(() => undefined);
+            }
+        });
+    }
+    async loadWithWal(agentId, name) {
+        const fs = require('fs');
+        const fsp = fs.promises;
+        const path = this.getRuntimePath(agentId, `${name}.json`);
+        const walPath = this.getRuntimePath(agentId, `${name}.wal`);
+        // 1. Check and recover from WAL if exists.
+        // Also serialize recovery with writes for the same (agentId,name) to avoid tmp/rename races.
+        if (fs.existsSync(walPath)) {
+            await this.queueWalWrite(agentId, name, async () => {
+                try {
+                    const walData = JSON.parse(await fsp.readFile(walPath, 'utf-8'));
+                    if (walData.data !== undefined) {
+                        // Recover from WAL
+                        const tmp = `${path}.tmp`;
+                        await fsp.writeFile(tmp, JSON.stringify(walData.data, null, 2), 'utf-8');
+                        await fsp.rename(tmp, path);
+                        await fsp.unlink(walPath).catch(() => undefined);
+                    }
+                }
+                catch (err) {
+                    console.error(`Failed to recover ${name} from WAL:`, err);
+                }
+            });
+        }
+        // 2. Load from main file
+        try {
+            const data = await fsp.readFile(path, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async queueWalWrite(agentId, name, write) {
+        const key = `${agentId}:${name}`;
+        // 链式追加，确保顺序执行
+        const previous = this.walQueue.get(key) || Promise.resolve();
+        const next = previous
+            .then(() => write()) // 前一个成功后执行
+            .catch((err) => {
+            // 即使前一个失败，也尝试当前写入
+            console.error(`[WAL] Previous write failed for ${key}, attempting current write:`, err);
+            return write();
+        });
+        this.walQueue.set(key, next);
+        try {
+            await next;
+        }
+        catch (err) {
+            // 记录但不阻塞调用者
+            console.error(`[WAL] Write failed for ${key}:`, err);
+            throw err; // 重新抛出让调用者处理
+        }
+        finally {
+            // 清理完成的 promise（避免内存泄漏）
+            if (this.walQueue.get(key) === next) {
+                this.walQueue.delete(key);
+            }
+        }
+    }
+    // ========== WAL 主动恢复 ==========
+    /**
+     * Store 初始化时主动恢复所有 WAL 文件
+     */
+    async recoverAllWALs() {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const agentDirs = await fs.readdir(this.baseDir).catch(() => []);
+            for (const agentId of agentDirs) {
+                const agentDir = path.join(this.baseDir, agentId);
+                const stat = await fs.stat(agentDir).catch(() => null);
+                if (!stat?.isDirectory())
+                    continue;
+                // 恢复运行时 WAL
+                await this.recoverRuntimeWAL(agentId, 'messages');
+                await this.recoverRuntimeWAL(agentId, 'tool-calls');
+                // 恢复事件 WAL
+                await this.recoverEventWALFile(agentId, 'progress');
+                await this.recoverEventWALFile(agentId, 'control');
+                await this.recoverEventWALFile(agentId, 'monitor');
+            }
+            if (agentDirs.length > 0) {
+                console.log(`[Store] WAL recovery completed for ${agentDirs.length} agents`);
+            }
+        }
+        catch (err) {
+            console.error('[Store] WAL recovery failed:', err);
+        }
+    }
+    /**
+     * 恢复运行时数据的 WAL
+     */
+    async recoverRuntimeWAL(agentId, name) {
+        const fs = require('fs');
+        const fsp = fs.promises;
+        const walKey = `${agentId}:${name}`;
+        if (this.walRecovered.has(walKey))
+            return;
+        this.walRecovered.add(walKey);
+        const path = this.getRuntimePath(agentId, `${name}.json`);
+        const walPath = this.getRuntimePath(agentId, `${name}.wal`);
+        if (!fs.existsSync(walPath))
+            return;
+        try {
+            const walData = JSON.parse(await fsp.readFile(walPath, 'utf-8'));
+            if (walData.data !== undefined) {
+                const tmp = `${path}.tmp`;
+                await fsp.writeFile(tmp, JSON.stringify(walData.data, null, 2), 'utf-8');
+                await fsp.rename(tmp, path);
+                await fsp.unlink(walPath);
+                console.log(`[Store] Recovered ${name} from WAL for ${agentId}`);
+            }
+        }
+        catch (err) {
+            console.error(`[Store] Failed to recover ${name} WAL for ${agentId}:`, err);
+            // 重命名损坏的 WAL 以便人工检查
+            await fsp.rename(walPath, `${walPath}.corrupted`).catch(() => { });
+        }
+    }
+    /**
+     * 恢复事件流的 WAL
+     */
+    async recoverEventWALFile(agentId, channel) {
+        const walKey = `${agentId}:${channel}`;
+        if (this.walRecovered.has(walKey))
+            return;
+        this.walRecovered.add(walKey);
+        const fs = require('fs');
+        const fsp = fs.promises;
+        const walPath = this.getEventsPath(agentId, `${channel}.wal`);
+        if (!fs.existsSync(walPath))
+            return;
+        try {
+            const data = await fsp.readFile(walPath, 'utf-8');
+            const lines = data.split('\n').filter(Boolean);
+            if (lines.length > 0) {
+                const payload = lines.join('\n') + '\n';
+                await fsp.appendFile(this.getEventsPath(agentId, `${channel}.log`), payload);
+                await fsp.unlink(walPath);
+                console.log(`[Store] Recovered ${lines.length} events from ${channel} WAL for ${agentId}`);
+            }
+        }
+        catch (err) {
+            console.error(`[Store] Failed to recover ${channel} WAL for ${agentId}:`, err);
+            await fsp.rename(walPath, `${walPath}.corrupted`).catch(() => { });
+        }
+    }
+    // ========== 事件流管理（按通道缓冲 + WAL） ==========
+    async appendEvent(agentId, timeline) {
+        const entry = JSON.stringify(timeline);
+        const channel = timeline.event.channel;
+        await this.recoverEventWal(agentId, channel);
+        const writers = this.getEventWriters(agentId);
+        const writer = writers[channel];
+        writer.buffer.push(entry);
+        await this.writeEventWal(agentId, channel, writer);
+        if (!writer.timer) {
+            writer.timer = setTimeout(() => {
+                void this.flushEvents(agentId, channel);
+            }, this.flushIntervalMs);
+        }
+    }
+    async *readEvents(agentId, opts) {
+        const channels = opts?.channel ? [opts.channel] : ['progress', 'control', 'monitor'];
+        for (const channel of channels) {
+            await this.recoverEventWal(agentId, channel);
+            await this.flushEvents(agentId, channel);
+            const fs = require('fs');
+            const readline = require('readline');
+            const path = this.getEventsPath(agentId, `${channel}.log`);
+            if (!fs.existsSync(path))
+                continue;
+            const stream = fs.createReadStream(path, { encoding: 'utf-8' });
+            const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+            for await (const line of rl) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (opts?.since && event.bookmark.seq <= opts.since.seq)
+                        continue;
+                    yield event;
+                }
+                catch {
+                    // skip corrupted lines
+                }
+            }
+        }
+    }
+    getEventWriters(agentId) {
+        let writers = this.eventWriters.get(agentId);
+        if (!writers) {
+            writers = {
+                progress: { buffer: [], flushing: [] },
+                control: { buffer: [], flushing: [] },
+                monitor: { buffer: [], flushing: [] },
+            };
+            this.eventWriters.set(agentId, writers);
+        }
+        return writers;
+    }
+    async flushEvents(agentId, channel) {
+        const writers = this.eventWriters.get(agentId);
+        if (!writers)
+            return;
+        const writer = writers[channel];
+        if (!writer)
+            return;
+        if (writer.timer) {
+            clearTimeout(writer.timer);
+            writer.timer = undefined;
+        }
+        if (writer.buffer.length > 0) {
+            writer.flushing.push(...writer.buffer);
+            writer.buffer = [];
+        }
+        if (writer.flushing.length === 0) {
+            await this.writeEventWal(agentId, channel, writer);
+            return;
+        }
+        const fsp = require('fs').promises;
+        const payload = writer.flushing.join('\n') + '\n';
+        await fsp.appendFile(this.getEventsPath(agentId, `${channel}.log`), payload);
+        writer.flushing = [];
+        await this.writeEventWal(agentId, channel, writer);
+    }
+    async recoverEventWal(agentId, channel) {
+        const walKey = `${agentId}:${channel}`;
+        if (this.walRecovered.has(walKey))
+            return;
+        const writers = this.getEventWriters(agentId);
+        const writer = writers[channel];
+        writer.recovered = true;
+        this.walRecovered.add(walKey);
+        const fs = require('fs');
+        const fsp = fs.promises;
+        const walPath = this.getEventsPath(agentId, `${channel}.wal`);
+        if (!fs.existsSync(walPath))
+            return;
+        try {
+            const data = await fsp.readFile(walPath, 'utf-8');
+            const lines = data.split('\n').filter(Boolean);
+            if (lines.length > 0) {
+                const payload = lines.join('\n') + '\n';
+                await fsp.appendFile(this.getEventsPath(agentId, `${channel}.log`), payload);
+            }
+            await fsp.unlink(walPath);
+        }
+        catch {
+            // WAL corrupted, keep it for manual inspection
+        }
+    }
+    async writeEventWal(agentId, channel, writer) {
+        const fs = require('fs');
+        const fsp = fs.promises;
+        const walPath = this.getEventsPath(agentId, `${channel}.wal`);
+        const schedule = async () => {
+            const entries = [...writer.flushing, ...writer.buffer];
+            if (entries.length > 0) {
+                await fsp.writeFile(walPath, entries.join('\n') + '\n', 'utf-8');
+            }
+            else if (fs.existsSync(walPath)) {
+                await fsp.unlink(walPath).catch(() => undefined);
+            }
+        };
+        writer.walWriting = (writer.walWriting || Promise.resolve()).then(schedule, schedule);
+        await writer.walWriting;
+    }
+    // ========== 历史与压缩管理 ==========
+    async saveHistoryWindow(agentId, window) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const dir = this.getHistoryDir(agentId, 'windows');
+        const filePath = path.join(dir, `${window.timestamp}.json`);
+        await fs.writeFile(filePath, JSON.stringify(window, null, 2), 'utf-8');
+    }
+    async loadHistoryWindows(agentId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dir = this.getHistoryDir(agentId, 'windows');
+            const files = await fs.readdir(dir);
+            const windows = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const data = await fs.readFile(path.join(dir, file), 'utf-8');
+                    windows.push(JSON.parse(data));
+                }
+            }
+            return windows.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        catch {
+            return [];
+        }
+    }
+    async saveCompressionRecord(agentId, record) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const dir = this.getHistoryDir(agentId, 'compressions');
+        const filePath = path.join(dir, `${record.timestamp}.json`);
+        await fs.writeFile(filePath, JSON.stringify(record, null, 2), 'utf-8');
+    }
+    async loadCompressionRecords(agentId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dir = this.getHistoryDir(agentId, 'compressions');
+            const files = await fs.readdir(dir);
+            const records = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const data = await fs.readFile(path.join(dir, file), 'utf-8');
+                    records.push(JSON.parse(data));
+                }
+            }
+            return records.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        catch {
+            return [];
+        }
+    }
+    async saveRecoveredFile(agentId, file) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const dir = this.getHistoryDir(agentId, 'recovered');
+        const safePath = file.path.replace(/[\/\\]/g, '_');
+        const filePath = path.join(dir, `${safePath}_${file.timestamp}.txt`);
+        const header = `# Recovered: ${file.path}\n# Timestamp: ${file.timestamp}\n# Mtime: ${file.mtime}\n\n`;
+        await fs.writeFile(filePath, header + file.content, 'utf-8');
+    }
+    async loadRecoveredFiles(agentId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dir = this.getHistoryDir(agentId, 'recovered');
+            const files = await fs.readdir(dir);
+            const recovered = [];
+            for (const file of files) {
+                const data = await fs.readFile(path.join(dir, file), 'utf-8');
+                const lines = data.split('\n');
+                const pathMatch = lines[0]?.match(/# Recovered: (.+)/);
+                const tsMatch = lines[1]?.match(/# Timestamp: (\d+)/);
+                const mtimeMatch = lines[2]?.match(/# Mtime: (\d+)/);
+                if (pathMatch && tsMatch && mtimeMatch) {
+                    recovered.push({
+                        path: pathMatch[1],
+                        content: lines.slice(4).join('\n'),
+                        mtime: parseInt(mtimeMatch[1]),
+                        timestamp: parseInt(tsMatch[1]),
+                    });
+                }
+            }
+            return recovered.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        catch {
+            return [];
+        }
+    }
+    // ========== 快照管理 ==========
+    async saveSnapshot(agentId, snapshot) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const dir = this.getSnapshotsDir(agentId);
+        const filePath = path.join(dir, `${snapshot.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(snapshot, null, 2), 'utf-8');
+    }
+    async loadSnapshot(agentId, snapshotId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dir = this.getSnapshotsDir(agentId);
+            const data = await fs.readFile(path.join(dir, `${snapshotId}.json`), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async listSnapshots(agentId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dir = this.getSnapshotsDir(agentId);
+            const files = await fs.readdir(dir);
+            const snapshots = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const data = await fs.readFile(path.join(dir, file), 'utf-8');
+                    snapshots.push(JSON.parse(data));
+                }
+            }
+            return snapshots;
+        }
+        catch {
+            return [];
+        }
+    }
+    // ========== 元数据管理 ==========
+    async saveInfo(agentId, info) {
+        const fs = require('fs').promises;
+        await fs.writeFile(this.getMetaPath(agentId), JSON.stringify(info, null, 2), 'utf-8');
+    }
+    async loadInfo(agentId) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getMetaPath(agentId), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // ========== 生命周期管理 ==========
+    async exists(agentId) {
+        const fs = require('fs').promises;
+        try {
+            await fs.access(this.getAgentDir(agentId));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async delete(agentId) {
+        const fs = require('fs').promises;
+        await fs.rm(this.getAgentDir(agentId), { recursive: true, force: true });
+    }
+    async list(prefix) {
+        const fs = require('fs').promises;
+        try {
+            const dirs = await fs.readdir(this.baseDir);
+            return prefix ? dirs.filter((d) => d.startsWith(prefix)) : dirs;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.JSONStore = JSONStore;

package/dist/skills/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent Skills 模块
+ *
+ * 提供对 Agent Skills 开放标准的支持
+ * https://agentskills.io
+ */
+export * from './types';
+export { SkillsParser } from './parser';
+export { SkillsValidator } from './validator';
+export { SkillsLoader } from './loader';
+export { SkillsManager } from './manager';
+export { SkillsInjector } from './injector';

package/dist/skills/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Agent Skills 模块
+ *
+ * 提供对 Agent Skills 开放标准的支持
+ * https://agentskills.io
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillsInjector = exports.SkillsManager = exports.SkillsLoader = exports.SkillsValidator = exports.SkillsParser = void 0;
+// 类型导出
+__exportStar(require("./types"), exports);
+// 核心类导出
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "SkillsParser", { enumerable: true, get: function () { return parser_1.SkillsParser; } });
+var validator_1 = require("./validator");
+Object.defineProperty(exports, "SkillsValidator", { enumerable: true, get: function () { return validator_1.SkillsValidator; } });
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "SkillsLoader", { enumerable: true, get: function () { return loader_1.SkillsLoader; } });
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "SkillsManager", { enumerable: true, get: function () { return manager_1.SkillsManager; } });
+var injector_1 = require("./injector");
+Object.defineProperty(exports, "SkillsInjector", { enumerable: true, get: function () { return injector_1.SkillsInjector; } });

package/dist/skills/injector.d.ts

@@ -0,0 +1,29 @@
+import { Skill, SkillMetadata } from './types';
+/**
+ * Skills 系统提示注入器
+ *
+ * 将 Skills 元数据转换为 XML 格式并注入系统提示
+ */
+export declare class SkillsInjector {
+    /**
+     * 生成 available_skills XML
+     *
+     * 遵循 Agent Skills 规范的推荐格式
+     *
+     * @param skills - Skills 列表（仅需元数据）
+     * @returns XML 格式的系统提示片段
+     */
+    static toPromptXML(skills: SkillMetadata[]): string;
+    /**
+     * 生成激活后的 skill_instructions XML
+     */
+    static toActivatedXML(skill: Skill): string;
+    /**
+     * 转义 XML 特殊字符
+     */
+    private static escapeXml;
+    /**
+     * 生成 Skills 总结（用于上下文压缩）
+     */
+    static toSummary(skills: Skill[]): string;
+}