@qlingzzy/qling 1.0.0

package/dist/memory.js

@@ -0,0 +1,632 @@
+// ============================================================
+// 轻灵 - Memory 系统 v3（WAL + 投影 Worker + LLM Dream）
+// 三层架构：Scratchpad（会话）→ Conversation（对话）→ Persisted（持久化）
+// ============================================================
+import * as fs from "fs/promises";
+import * as path from "path";
+import { ProjectionWorker } from "./memory/projection-worker.js";
+import { MemoryCompactor } from "./memory/compactor.js";
+import * as crypto from "crypto";
+const DEFAULT_CONFIG = {
+    enabled: true,
+    turnThreshold: 24,
+    transcriptWindow: 4,
+    semanticEnabled: false,
+};
+// --- PersistedMemory（长期存储，WAL 模式可选）---
+export class PersistedMemory {
+    entries = [];
+    memoryDir;
+    wal = null;
+    projectionWorker = null;
+    // v0.5 认知引擎
+    cognitiveIndex = null;
+    embeddingClient = null;
+    constructor(memoryDir) {
+        this.memoryDir = memoryDir;
+    }
+    setWAL(wal, options = {}) {
+        this.wal = wal;
+        this.projectionWorker = new ProjectionWorker(wal, {
+            applyEntry: (entry) => this.applyWALEntry(entry),
+            getEntries: () => this.entries,
+            onCheckpoint: async (entries) => this.syncCognitiveIndex(entries),
+        }, {
+            intervalMs: options.intervalMs,
+            maxPendingEntries: options.maxPendingEntries,
+        });
+    }
+    setCognitiveIndex(index, client) {
+        this.cognitiveIndex = index;
+        this.embeddingClient = client;
+    }
+    async init() {
+        await fs.mkdir(this.memoryDir, { recursive: true });
+        await this.loadFromDisk();
+        if (this.cognitiveIndex) {
+            await this.cognitiveIndex.init();
+        }
+    }
+    add(content, source, importance = 0.5) {
+        const entry = {
+            id: "mem_" + Date.now() + "_" + Math.random().toString(36).slice(2, 7),
+            content,
+            source,
+            createdAt: Date.now(),
+            importance,
+        };
+        this.entries.push(entry);
+        this.entries.sort((a, b) => b.importance - a.importance);
+    }
+    remove(id) {
+        const idx = this.entries.findIndex((e) => e.id === id);
+        if (idx === -1)
+            return false;
+        this.entries.splice(idx, 1);
+        return true;
+    }
+    update(id, updates) {
+        const entry = this.entries.find((e) => e.id === id);
+        if (!entry)
+            return false;
+        if (updates.content !== undefined)
+            entry.content = updates.content;
+        if (updates.importance !== undefined)
+            entry.importance = updates.importance;
+        this.entries.sort((a, b) => b.importance - a.importance);
+        return true;
+    }
+    applyWALEntry(entry) {
+        switch (entry.op) {
+            case "add": {
+                const data = entry.data;
+                if (!this.entries.some((e) => e.id === data.id)) {
+                    this.entries.push(data);
+                    this.entries.sort((a, b) => b.importance - a.importance);
+                }
+                break;
+            }
+            case "remove": {
+                const data = entry.data;
+                this.entries = this.entries.filter((e) => e.id !== data.id);
+                break;
+            }
+            case "update": {
+                const data = entry.data;
+                const existing = this.entries.find((e) => e.id === data.id);
+                if (existing) {
+                    if (data.content !== undefined)
+                        existing.content = data.content;
+                    if (data.importance !== undefined)
+                        existing.importance = data.importance;
+                }
+                break;
+            }
+            case "compact": {
+                const data = entry.data;
+                this.entries = data;
+                break;
+            }
+        }
+    }
+    async getRelevant(query, limit = 5) {
+        const now = Date.now();
+        // 1. 关键词检索
+        const keywordResults = this.entries.map((e) => {
+            let score = e.importance;
+            const ageHours = (now - e.createdAt) / (1000 * 60 * 60);
+            score *= Math.pow(0.9, ageHours / 24);
+            const keywords = query.toLowerCase().split(/\s+/);
+            const content = e.content.toLowerCase();
+            const matches = keywords.filter((k) => content.includes(k)).length;
+            score += matches * 0.1;
+            return { entry: e, score, source: "keyword" };
+        });
+        // 2. 向量检索 (v0.3+)
+        let semanticResults = [];
+        if (this.cognitiveIndex && this.embeddingClient && query.trim()) {
+            try {
+                const queryVector = await this.embeddingClient.getEmbedding(query);
+                const searchHits = this.cognitiveIndex.searchVector(queryVector, limit * 2);
+                semanticResults = searchHits.map(h => ({
+                    entry: h.entry,
+                    score: h.score * 0.8,
+                    source: "vector"
+                }));
+            }
+            catch (err) {
+                // 专项修复：处理 404 (Endpoint 不支持)
+                if (err.message.includes("404")) {
+                    if (!this._warned404) {
+                        console.warn(`[Memory] ⚠️ 当前提供商不支持 Embedding 接口 (404)，已降级为纯关键词检索模式。`);
+                        this._warned404 = true;
+                    }
+                }
+                else {
+                    console.error(`[PersistedMemory] Vector search failed: ${err.message}`);
+                }
+            }
+        }
+        // 3. 经验检索 (v0.5 M1)
+        const practices = this.cognitiveIndex?.getRelatedPractices(query) || [];
+        const practiceResults = practices.map(p => ({
+            id: p.id,
+            content: `[最佳实践] 任务模式: ${p.task_pattern} | 成功路径: ${JSON.parse(p.action_json).join(" -> ")}`,
+            source: "practice",
+            importance: p.confidence,
+            createdAt: p.created_at
+        }));
+        // 4. 混合排序 (Hybrid Rerank)
+        const merged = new Map();
+        keywordResults.forEach(r => merged.set(r.entry.id, r));
+        semanticResults.forEach(r => {
+            const existing = merged.get(r.entry.id);
+            if (existing)
+                existing.score += r.score;
+            else
+                merged.set(r.entry.id, r);
+        });
+        practiceResults.forEach(p => {
+            merged.set(p.id, { entry: p, score: 2.0 });
+        });
+        return Array.from(merged.values())
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map((s) => s.entry);
+    }
+    async syncCognitiveIndex(entries) {
+        if (!this.cognitiveIndex || !this.embeddingClient)
+            return;
+        const batchSize = 10;
+        const entriesToIndex = entries.slice(-batchSize);
+        try {
+            const vectors = await this.embeddingClient.getEmbeddings(entriesToIndex.map(e => e.content));
+            for (let i = 0; i < entriesToIndex.length; i++) {
+                this.cognitiveIndex.upsertVector(entriesToIndex[i], vectors[i]);
+            }
+        }
+        catch (err) {
+            const msg = err.message || String(err);
+            if (msg.includes("404")) {
+                if (!this._semanticWarned404) {
+                    console.warn(`[Memory] ⚠️ 当前提供商不支持 Embedding 接口 (404)，已禁用语义索引（降级为关键词+实践检索）。请为语义记忆配置支持 embeddings 的 provider（如 OpenAI）或设置 QLING_MEMORY_SEMANTIC_ENDPOINT / _MODEL。`);
+                    this._semanticWarned404 = true;
+                    // 禁用后续索引
+                    this.embeddingClient = null;
+                }
+            }
+            else {
+                console.error(`[PersistedMemory] Async cognitive indexing failed: ${msg}`);
+            }
+        }
+    }
+    /** 建立知识关联 */
+    link(source, relation, target) {
+        this.cognitiveIndex?.link(source, relation, target);
+    }
+    linkSessionToEntities(sessionId, summary, files, tasks) {
+        this.cognitiveIndex?.linkSessionToEntities(sessionId, summary, files, tasks);
+    }
+    /** 记录最佳实践 */
+    addPractice(pattern, commands, files, confidence = 1.0) {
+        this.cognitiveIndex?.addPractice({
+            id: "prac_" + Date.now(),
+            task_pattern: pattern,
+            successful_commands: commands,
+            files_involved: files,
+            confidence,
+        });
+    }
+    formatForPrompt(limit = 10) {
+        if (this.entries.length === 0)
+            return "";
+        const relevant = this.getRelevantSync("", limit);
+        if (relevant.length === 0)
+            return "";
+        return relevant
+            .map((e) => "[" + e.source + "] " + e.content)
+            .join("\n");
+    }
+    getRelevantSync(query, limit = 5) {
+        const now = Date.now();
+        const scored = this.entries.map((e) => {
+            let score = e.importance;
+            const ageHours = (now - e.createdAt) / (1000 * 60 * 60);
+            score *= Math.pow(0.9, ageHours / 24);
+            const keywords = query.toLowerCase().split(/\s+/);
+            const content = e.content.toLowerCase();
+            const matches = keywords.filter((k) => content.includes(k)).length;
+            score += matches * 0.1;
+            return { entry: e, score };
+        });
+        return scored
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map((s) => s.entry);
+    }
+    async saveToDisk() {
+        if (this.wal) {
+            await this.wal.append("compact", this.entries);
+        }
+        else {
+            const file = path.join(this.memoryDir, "memory.json");
+            await fs.writeFile(file, JSON.stringify(this.entries, null, 2), "utf-8");
+        }
+    }
+    async loadFromDisk() {
+        try {
+            const file = path.join(this.memoryDir, "memory.json");
+            const data = await fs.readFile(file, "utf-8");
+            this.entries = JSON.parse(data);
+        }
+        catch {
+            this.entries = [];
+        }
+    }
+    merge(entries) {
+        const existing = new Map(this.entries.map((e) => [e.id, e]));
+        for (const entry of entries) {
+            existing.set(entry.id, entry);
+        }
+        this.entries = Array.from(existing.values());
+        this.entries.sort((a, b) => b.importance - a.importance);
+    }
+    getAll() {
+        return [...this.entries];
+    }
+    compact(maxEntries = 1000) {
+        const compactor = new MemoryCompactor({ maxEntries });
+        const result = compactor.compactWithEntries(this.entries);
+        this.entries = result.entries;
+    }
+    startProjection() {
+        this.projectionWorker?.start();
+    }
+    stopProjection() {
+        this.projectionWorker?.stop();
+    }
+    async forceCheckpoint() {
+        await this.projectionWorker?.forceCheckpoint();
+    }
+    async rebuildSemanticIndex() {
+        if (!this.cognitiveIndex || !this.embeddingClient)
+            return;
+        this.cognitiveIndex.close();
+        await this.cognitiveIndex.init();
+        const batchSize = 10;
+        for (let i = 0; i < this.entries.length; i += batchSize) {
+            const batch = this.entries.slice(i, i + batchSize);
+            try {
+                const vectors = await this.embeddingClient.getEmbeddings(batch.map(e => e.content));
+                for (let j = 0; j < batch.length; j++) {
+                    this.cognitiveIndex.upsertVector(batch[j], vectors[j]);
+                }
+            }
+            catch (err) {
+                console.error(`[PersistedMemory] rebuildSemanticIndex batch failed: ${err.message}`);
+                break; // stop on failure
+            }
+        }
+    }
+    async shutdown() {
+        this.stopProjection();
+        await this.forceCheckpoint();
+        if (this.cognitiveIndex) {
+            this.cognitiveIndex.close();
+        }
+    }
+    getCognitiveIndex() {
+        return this.cognitiveIndex;
+    }
+}
+// --- ScratchpadMemory（会话笔记，临时，Agent 自己写入读取）---
+export class ScratchpadMemory {
+    notes = new Map();
+    set(key, value) {
+        this.notes.set(key, value);
+    }
+    get(key) {
+        return this.notes.get(key);
+    }
+    has(key) {
+        return this.notes.has(key);
+    }
+    delete(key) {
+        this.notes.delete(key);
+    }
+    entries() {
+        return this.notes.entries();
+    }
+    formatForPrompt() {
+        if (this.notes.size === 0)
+            return "";
+        const lines = Array.from(this.notes.entries()).map(([k, v]) => "- " + k + ": " + v);
+        return "[会话笔记]\n" + lines.join("\n");
+    }
+    clear() {
+        this.notes.clear();
+    }
+}
+export class ConversationMemory {
+    turns = [];
+    add(role, content) {
+        this.turns.push({ role, content, timestamp: Date.now() });
+    }
+    getRecent(count = 10) {
+        return this.turns.slice(-count);
+    }
+    getAll() {
+        return [...this.turns];
+    }
+    count() {
+        return this.turns.length;
+    }
+    clear() {
+        this.turns = [];
+    }
+    extractKeyInfo() {
+        const recent = this.turns.slice(-8);
+        const lines = [];
+        for (const t of recent) {
+            const paths = t.content.match(/[/\.a-zA-Z0-9_-]+\.(ts|js|py|md|json|yml|yaml|sh)/g);
+            if (paths)
+                lines.push(...paths);
+            const techs = t.content.match(/(?:使用|调用|通过)\s+(\S+)/g);
+            if (techs)
+                lines.push(...techs);
+        }
+        return Array.from(new Set(lines));
+    }
+}
+// --- Unified MemoryStore（统一入口，组合三层）---
+export class MemoryStore {
+    persisted; // Workspace persisted memory (for compatibility)
+    globalPersisted;
+    scratchpad;
+    conversation;
+    config;
+    workspaceMemoryDir;
+    globalMemoryDir;
+    constructor(memoryDir, config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        const workspaceDir = config.workspaceDir || process.cwd();
+        const wsHash = crypto.createHash("sha256").update(path.resolve(workspaceDir)).digest("hex").slice(0, 16);
+        // If memoryDir ends with "memory", assume it is the runtime root memory directory.
+        const parentDir = memoryDir.endsWith("memory") ? memoryDir : path.join(path.dirname(memoryDir), "memory");
+        this.globalMemoryDir = path.join(parentDir, "global");
+        this.workspaceMemoryDir = path.join(parentDir, "workspace", wsHash);
+        this.persisted = new PersistedMemory(this.workspaceMemoryDir);
+        this.globalPersisted = new PersistedMemory(this.globalMemoryDir);
+        this.scratchpad = new ScratchpadMemory();
+        this.conversation = new ConversationMemory();
+    }
+    async init() {
+        await this.globalPersisted.init();
+        await this.persisted.init();
+    }
+    setWAL(wal, options = {}) {
+        this.persisted.setWAL(wal, options);
+    }
+    setCognitiveIndex(index, client) {
+        this.persisted.setCognitiveIndex(index, client);
+    }
+    startProjection() {
+        this.persisted.startProjection();
+    }
+    stopProjection() {
+        this.persisted.stopProjection();
+    }
+    async forceCheckpoint() {
+        await this.persisted.forceCheckpoint();
+    }
+    async shutdown() {
+        await this.globalPersisted.shutdown();
+        await this.persisted.shutdown();
+    }
+    async rebuildSemanticIndex() {
+        await this.persisted.rebuildSemanticIndex();
+    }
+    getCognitiveIndex() {
+        return this.persisted.getCognitiveIndex();
+    }
+    // --- Persisted（对外 API）---
+    add(content, source, importance = 0.5, scope = "workspace") {
+        if (scope === "global") {
+            this.globalPersisted.add(content, source, importance);
+        }
+        else {
+            this.persisted.add(content, source, importance);
+        }
+    }
+    remove(id, scope = "workspace") {
+        if (scope === "global") {
+            return this.globalPersisted.remove(id);
+        }
+        else {
+            return this.persisted.remove(id);
+        }
+    }
+    update(id, updates, scope = "workspace") {
+        if (scope === "global") {
+            return this.globalPersisted.update(id, updates);
+        }
+        else {
+            return this.persisted.update(id, updates);
+        }
+    }
+    applyOperations(ops, scope = "workspace") {
+        for (const op of ops) {
+            switch (op.action) {
+                case "ADD":
+                    this.add(op.fact, "dream-consolidation", 0.6, scope);
+                    break;
+                case "UPDATE":
+                    if (op.targetId) {
+                        this.update(op.targetId, { content: op.fact }, scope);
+                    }
+                    break;
+                case "DELETE":
+                    if (op.targetId) {
+                        this.remove(op.targetId, scope);
+                    }
+                    break;
+            }
+        }
+    }
+    async getRelevant(query, limit = 5) {
+        const wsHits = await this.persisted.getRelevant(query, limit);
+        const globalHits = await this.globalPersisted.getRelevant(query, limit);
+        const merged = new Map();
+        // Project/workspace memories get a weight multiplier of 1.0
+        wsHits.forEach((entry, idx) => {
+            const score = (limit - idx) * 1.0;
+            merged.set("ws:" + entry.id, { entry, score });
+        });
+        // Global memories get a weight multiplier of 0.7
+        globalHits.forEach((entry, idx) => {
+            const score = (limit - idx) * 0.7;
+            const key = "global:" + entry.id;
+            merged.set(key, { entry, score });
+        });
+        return Array.from(merged.values())
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map((s) => s.entry);
+    }
+    // --- Cognitive Layer (M1) ---
+    link(source, relation, target) {
+        this.persisted.link(source, relation, target);
+    }
+    linkSessionToEntities(sessionId, summary, files, tasks) {
+        this.persisted.linkSessionToEntities(sessionId, summary, files, tasks);
+    }
+    addPractice(pattern, commands, files) {
+        this.persisted.addPractice(pattern, commands, files);
+    }
+    // --- Scratchpad（对外 API）---
+    setNote(key, value) {
+        this.scratchpad.set(key, value);
+    }
+    getNote(key) {
+        return this.scratchpad.get(key);
+    }
+    deleteNote(key) {
+        this.scratchpad.delete(key);
+    }
+    // --- Conversation（对外 API）---
+    addConversationTurn(role, content) {
+        this.conversation.add(role, content);
+    }
+    getConversationCount() {
+        return this.conversation.count();
+    }
+    // --- Scratchpad → Persisted（笔记提升为持久记忆）---
+    promoteNoteToMemory(key, importance = 0.6) {
+        const value = this.scratchpad.get(key);
+        if (!value)
+            return false;
+        this.persisted.add("[笔记->记忆] " + key + ": " + value, "manual", importance);
+        this.scratchpad.delete(key);
+        return true;
+    }
+    // --- 统一接口：格式化提示字符串 ---
+    formatPromptForContext(limit = 10) {
+        const parts = [];
+        const scratchpadStr = this.scratchpad.formatForPrompt();
+        if (scratchpadStr)
+            parts.push(scratchpadStr);
+        const persistedStr = this.persisted.formatForPrompt(limit);
+        if (persistedStr)
+            parts.push(persistedStr);
+        const globalStr = this.globalPersisted.formatForPrompt(limit);
+        if (globalStr)
+            parts.push("[全局记忆]\n" + globalStr);
+        if (parts.length === 0)
+            return null;
+        return parts.join("\n\n");
+    }
+    // --- 统一接口：保存到磁盘 ---
+    async saveToDisk() {
+        await this.globalPersisted.saveToDisk();
+        await this.persisted.saveToDisk();
+    }
+    // --- 会话重置（不清持久化）---
+    resetSession() {
+        this.scratchpad.clear();
+        this.conversation.clear();
+    }
+    // --- 全量导出（用于压缩合并）---
+    exportPersisted() {
+        return this.persisted.getAll();
+    }
+    // --- 全量导入（用于压缩合并后恢复）---
+    importPersisted(entries) {
+        this.persisted.merge(entries);
+    }
+    compactPersisted(maxEntries) {
+        this.persisted.compact(maxEntries);
+    }
+    getWorkspaceMemoryDir() {
+        return this.workspaceMemoryDir;
+    }
+    getGlobalMemoryDir() {
+        return this.globalMemoryDir;
+    }
+}
+export async function extractDreamMemories(ctx, config) {
+    if (ctx.turnCount < config.turnThreshold)
+        return [];
+    const recent = ctx.transcript.slice(-(config.transcriptWindow ?? 4));
+    const combined = recent.join("\n---\n");
+    const patterns = [
+        /(?:记住|记得|重要|不要忘记)[：:]\s*(.+)/gi,
+        /(?:项目|技术栈|框架)[：:]\s*(\S+)/gi,
+        /(?:工作目录)[：:]\s*(\S+)/gi,
+        /(?:使用|调用)[：:]\s*(\S+)/gi,
+        /([/\.a-zA-Z0-9_-]+\.(?:ts|js|py|md|json|yml|yaml|sh))/g,
+    ];
+    const memories = [];
+    for (const pat of patterns) {
+        let match;
+        while ((match = pat.exec(combined)) !== null) {
+            memories.push(match[1].trim());
+        }
+    }
+    return Array.from(new Set(memories));
+}
+// --- Token Budget Manager ---
+export class TokenBudgetManager {
+    maxTokens;
+    nudgeThreshold;
+    usedTokens;
+    constructor(maxTokens, nudgeThreshold = 0.2, usedTokens = 0) {
+        this.maxTokens = maxTokens;
+        this.nudgeThreshold = nudgeThreshold;
+        this.usedTokens = usedTokens;
+    }
+    addUsage(tokens) {
+        this.usedTokens += tokens;
+    }
+    syncUsage(actualTokens) {
+        this.usedTokens = actualTokens;
+    }
+    reset() {
+        this.usedTokens = 0;
+    }
+    getRemaining() {
+        return this.maxTokens - this.usedTokens;
+    }
+    getRemainingPct() {
+        return this.getRemaining() / this.maxTokens;
+    }
+    shouldNudge() {
+        return this.getRemainingPct() < this.nudgeThreshold;
+    }
+    buildNudgeMessage() {
+        const pct = Math.round(this.getRemainingPct() * 100);
+        return "Token 预算即将耗尽（剩余 " + pct + "%），请精简回复，减少工具调用频率。";
+    }
+    estimateMessagesCost(messages) {
+        return messages.reduce((sum, m) => sum + m.content.length * 4, 0);
+    }
+}

package/dist/metrics/agent-telemetry.d.ts

@@ -0,0 +1,14 @@
+import { MetricsCollector } from "./collector.js";
+export declare class AgentTelemetry {
+    private collector;
+    private sessionId;
+    constructor(collector: MetricsCollector, sessionId: string);
+    recordTurnStart(turn: number): void;
+    recordTurnEnd(turn: number, toolCalls: number, toolFailures: number, tokens: number): void;
+    recordToolCall(toolName: string, durationMs: number, success: boolean): void;
+    recordCompaction(before: number, after: number): void;
+    recordMemoryWrite(source: string): void;
+    recordSessionEnd(): void;
+    flush(): Promise<void>;
+}
+//# sourceMappingURL=agent-telemetry.d.ts.map

package/dist/metrics/agent-telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-telemetry.d.ts","sourceRoot":"","sources":["../../src/metrics/agent-telemetry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,SAAS,CAAS;gBAEd,SAAS,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM;IAK1D,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAInC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAO1F,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAO5E,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAOrD,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOvC,gBAAgB,IAAI,IAAI;IAIlB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/metrics/agent-telemetry.js

@@ -0,0 +1,44 @@
+// ============================================================
+// 轻灵 - Agent Telemetry（Agent 遥测封装）
+// ============================================================
+export class AgentTelemetry {
+    collector;
+    sessionId;
+    constructor(collector, sessionId) {
+        this.collector = collector;
+        this.sessionId = sessionId;
+    }
+    recordTurnStart(turn) {
+        this.collector.record({ type: "turn_complete", data: { turn, phase: "start" } });
+    }
+    recordTurnEnd(turn, toolCalls, toolFailures, tokens) {
+        this.collector.record({
+            type: "turn_complete",
+            data: { turn, toolCalls, toolFailures, tokens },
+        });
+    }
+    recordToolCall(toolName, durationMs, success) {
+        this.collector.record({
+            type: success ? "tool_call" : "tool_error",
+            data: { toolName, durationMs },
+        });
+    }
+    recordCompaction(before, after) {
+        this.collector.record({
+            type: "compaction",
+            data: { before, after, removed: before - after },
+        });
+    }
+    recordMemoryWrite(source) {
+        this.collector.record({
+            type: "memory_write",
+            data: { source },
+        });
+    }
+    recordSessionEnd() {
+        this.collector.record({ type: "session_end", data: {} });
+    }
+    async flush() {
+        await this.collector.flush();
+    }
+}