@qlingzzy/qling 1.0.0

package/dist/memory-report.js

@@ -0,0 +1,726 @@
+import { access, readFile } from "fs/promises";
+import { join, dirname } from "path";
+import Database from "better-sqlite3";
+const DEFAULT_MEMORY_COUNT = 10;
+const MAX_MEMORY_COUNT = 50;
+function getMemoryDir(stateDir) {
+    const normalized = stateDir.replace(/\\/g, "/");
+    if (normalized.includes("/memory/workspace") ||
+        normalized.includes("/memory/global") ||
+        normalized.endsWith("/memory")) {
+        return stateDir;
+    }
+    return join(stateDir, "memory");
+}
+function getRuntimeRootDir(stateDir, memoryDir) {
+    if (memoryDir !== stateDir) {
+        return stateDir;
+    }
+    const normalized = stateDir.replace(/\\/g, "/");
+    if (normalized.includes("/memory/workspace/")) {
+        return dirname(dirname(dirname(stateDir)));
+    }
+    if (normalized.includes("/memory/global")) {
+        return dirname(dirname(stateDir));
+    }
+    if (normalized.endsWith("/memory")) {
+        return dirname(stateDir);
+    }
+    return stateDir;
+}
+export function parseMemoryReportCount(value) {
+    if (value === undefined || value === null || value === "")
+        return DEFAULT_MEMORY_COUNT;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_MEMORY_COUNT;
+    return Math.min(Math.floor(parsed), MAX_MEMORY_COUNT);
+}
+export function parseMemorySearchArgs(args) {
+    const trimmed = args.map((arg) => String(arg).trim()).filter(Boolean);
+    if (!trimmed.length)
+        return { query: "", count: DEFAULT_MEMORY_COUNT };
+    const last = trimmed[trimmed.length - 1];
+    const lastIsNumeric = /^-?\d+(?:\.\d+)?$/.test(last);
+    const count = lastIsNumeric ? parseMemoryReportCount(last) : DEFAULT_MEMORY_COUNT;
+    const queryParts = lastIsNumeric ? trimmed.slice(0, -1) : trimmed;
+    return {
+        query: queryParts.join(" ").trim(),
+        count,
+    };
+}
+function emptyCounts() {
+    return {
+        embeddings: null,
+        kgNodes: null,
+        kgEdges: null,
+        distilledPractices: null,
+    };
+}
+function formatCreatedAt(value) {
+    const numeric = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return "-";
+    const date = new Date(numeric);
+    return Number.isNaN(date.getTime()) ? "-" : date.toISOString();
+}
+function normalizePreview(content, maxLength = 140) {
+    const compact = content.replace(/\s+/g, " ").trim();
+    if (compact.length <= maxLength)
+        return compact;
+    return `${compact.slice(0, maxLength - 1)}…`;
+}
+function normalizeEntry(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const raw = value;
+    if (typeof raw.id !== "string" || !raw.id.trim())
+        return null;
+    if (typeof raw.content !== "string")
+        return null;
+    return {
+        id: raw.id,
+        content: raw.content,
+        source: typeof raw.source === "string" ? raw.source : "unknown",
+        createdAt: typeof raw.createdAt === "number" ? raw.createdAt : Number(raw.createdAt) || 0,
+        importance: typeof raw.importance === "number" ? raw.importance : Number(raw.importance) || 0,
+    };
+}
+async function loadPersistedEntries(memoryFile, warnings) {
+    try {
+        const raw = await readFile(memoryFile, "utf8");
+        const parsed = JSON.parse(raw);
+        const values = Array.isArray(parsed)
+            ? parsed
+            : parsed && typeof parsed === "object" && Array.isArray(parsed.entries)
+                ? parsed.entries
+                : [];
+        return values.map(normalizeEntry).filter((entry) => entry !== null);
+    }
+    catch (error) {
+        const code = error && typeof error === "object" ? error.code : undefined;
+        if (code !== "ENOENT") {
+            warnings.push(`memory.json unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return [];
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function countTable(db, table) {
+    const tableRow = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?")
+        .get(table);
+    if (!tableRow?.name)
+        return null;
+    const row = db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get();
+    return Number(row?.count ?? 0);
+}
+function hasTable(db, table) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?")
+        .get(table);
+    return Boolean(row?.name);
+}
+async function readCognitiveIndexCounts(dbPath, warnings) {
+    if (!(await exists(dbPath)))
+        return emptyCounts();
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        return {
+            embeddings: countTable(db, "embeddings"),
+            kgNodes: countTable(db, "kg_nodes"),
+            kgEdges: countTable(db, "kg_edges"),
+            distilledPractices: countTable(db, "distilled_practices"),
+        };
+    }
+    catch (error) {
+        warnings.push(`cognitive_knowledge.db unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        return emptyCounts();
+    }
+    finally {
+        db?.close();
+    }
+}
+function sortEntries(entries) {
+    return [...entries].sort((left, right) => {
+        const timeDelta = right.createdAt - left.createdAt;
+        if (timeDelta !== 0)
+            return timeDelta;
+        const importanceDelta = right.importance - left.importance;
+        if (importanceDelta !== 0)
+            return importanceDelta;
+        return left.id.localeCompare(right.id);
+    });
+}
+function toReportEntry(entry) {
+    return {
+        ...entry,
+        createdAtIso: formatCreatedAt(entry.createdAt),
+        preview: normalizePreview(entry.content),
+    };
+}
+function valueToPreview(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value === null || value === undefined)
+        return "";
+    return JSON.stringify(value);
+}
+function summarizeJsonField(raw, id, label, warnings) {
+    try {
+        const parsed = JSON.parse(raw);
+        const values = Array.isArray(parsed)
+            ? parsed
+            : parsed && typeof parsed === "object" && Array.isArray(parsed.files)
+                ? parsed.files
+                : parsed && typeof parsed === "object" && Array.isArray(parsed.commands)
+                    ? parsed.commands
+                    : [parsed];
+        const previewItems = values.map(valueToPreview).filter(Boolean);
+        return {
+            count: previewItems.length,
+            preview: previewItems.slice(0, 3).join(" | ") || "-",
+        };
+    }
+    catch (error) {
+        warnings.push(`${id} ${label} json unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            count: raw ? 1 : 0,
+            preview: raw || "-",
+        };
+    }
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+function tokenizeQuery(query) {
+    return unique(query.toLowerCase().split(/\s+/).map((token) => token.trim()).filter(Boolean));
+}
+function matchEntry(entry, query) {
+    const normalizedQuery = query.toLowerCase().trim();
+    if (!normalizedQuery)
+        return null;
+    const content = entry.content.toLowerCase();
+    const source = entry.source.toLowerCase();
+    const id = entry.id.toLowerCase();
+    const tokens = tokenizeQuery(normalizedQuery);
+    let score = 0;
+    const matchedVia = [];
+    if (content.includes(normalizedQuery)) {
+        score += 10;
+        matchedVia.push("content:phrase");
+    }
+    for (const token of tokens) {
+        if (content.includes(token)) {
+            score += 5;
+            matchedVia.push(`content:${token}`);
+        }
+        if (source.includes(token)) {
+            score += 3;
+            matchedVia.push(`source:${token}`);
+        }
+        if (id.includes(token)) {
+            score += 2;
+            matchedVia.push(`id:${token}`);
+        }
+    }
+    if (!matchedVia.length)
+        return null;
+    return { score, matchedVia: unique(matchedVia) };
+}
+export async function buildLocalMemoryReport(stateDir, options = {}) {
+    const requestedCount = parseMemoryReportCount(options.count);
+    const memoryDir = getMemoryDir(stateDir);
+    const memoryFile = join(memoryDir, "memory.json");
+    const cognitiveIndexDb = join(memoryDir, "cognitive_knowledge.db");
+    const warnings = [];
+    const entries = sortEntries(await loadPersistedEntries(memoryFile, warnings));
+    const cognitiveIndex = await readCognitiveIndexCounts(cognitiveIndexDb, warnings);
+    return {
+        stateDir,
+        memoryDir,
+        memoryFile,
+        cognitiveIndexDb,
+        entries: entries.slice(0, requestedCount).map(toReportEntry),
+        totalEntries: entries.length,
+        requestedCount,
+        truncated: entries.length > requestedCount,
+        cognitiveIndex,
+        warnings,
+    };
+}
+export async function buildLocalMemorySourcesReport(stateDir) {
+    const memoryDir = getMemoryDir(stateDir);
+    const runtimeRootDir = getRuntimeRootDir(stateDir, memoryDir);
+    const sourceSpecs = [
+        {
+            id: "persisted_memory",
+            label: "Persisted memory",
+            path: join(memoryDir, "memory.json"),
+            role: "context recall",
+            boundary: "条目内容可被显式列表、搜索和详情审计；本报告只检查文件存在性。",
+        },
+        {
+            id: "cognitive_index",
+            label: "Cognitive index",
+            path: join(memoryDir, "cognitive_knowledge.db"),
+            role: "context recall metadata",
+            boundary: "只用于向量、知识图谱和蒸馏实践索引；本报告不打开数据库。",
+        },
+        {
+            id: "session_checkpoints",
+            label: "Session checkpoints",
+            path: join(runtimeRootDir, "sessions"),
+            role: "resume metadata",
+            boundary: "用于会话恢复和 checkpoint；本报告不读取 session 正文。",
+        },
+        {
+            id: "goal_task_state",
+            label: "Goal and task state",
+            path: runtimeRootDir,
+            role: "task progress metadata",
+            boundary: "goal/task 进度保存在 session-goals、session-tasks 等本地文件；本报告不读取任务正文。",
+        },
+    ];
+    const sources = await Promise.all(sourceSpecs.map(async (source) => ({
+        ...source,
+        exists: await exists(source.path),
+    })));
+    return { stateDir, sources };
+}
+export async function searchLocalMemoryEntries(stateDir, request) {
+    const requestedCount = parseMemoryReportCount(request.count);
+    const query = (request.query ?? "").trim();
+    const memoryDir = getMemoryDir(stateDir);
+    const memoryFile = join(memoryDir, "memory.json");
+    const warnings = [];
+    const entries = await loadPersistedEntries(memoryFile, warnings);
+    const matches = query
+        ? entries.flatMap((entry) => {
+            const match = matchEntry(entry, query);
+            if (!match)
+                return [];
+            return [{ ...toReportEntry(entry), ...match }];
+        })
+        : [];
+    matches.sort((left, right) => {
+        const scoreDelta = right.score - left.score;
+        if (scoreDelta !== 0)
+            return scoreDelta;
+        const importanceDelta = right.importance - left.importance;
+        if (importanceDelta !== 0)
+            return importanceDelta;
+        const timeDelta = right.createdAt - left.createdAt;
+        if (timeDelta !== 0)
+            return timeDelta;
+        return left.id.localeCompare(right.id);
+    });
+    return {
+        stateDir,
+        memoryDir,
+        memoryFile,
+        query,
+        entries: matches.slice(0, requestedCount),
+        totalEntries: entries.length,
+        totalMatches: matches.length,
+        requestedCount,
+        truncated: matches.length > requestedCount,
+        warnings,
+    };
+}
+export async function listLocalMemoryPractices(stateDir, options = {}) {
+    const requestedCount = parseMemoryReportCount(options.count);
+    const memoryDir = getMemoryDir(stateDir);
+    const cognitiveIndexDb = join(memoryDir, "cognitive_knowledge.db");
+    const warnings = [];
+    if (!(await exists(cognitiveIndexDb))) {
+        return {
+            stateDir,
+            memoryDir,
+            cognitiveIndexDb,
+            entries: [],
+            totalPractices: 0,
+            requestedCount,
+            truncated: false,
+            warnings,
+        };
+    }
+    let db = null;
+    try {
+        db = new Database(cognitiveIndexDb, { readonly: true, fileMustExist: true });
+        if (!hasTable(db, "distilled_practices")) {
+            return {
+                stateDir,
+                memoryDir,
+                cognitiveIndexDb,
+                entries: [],
+                totalPractices: 0,
+                requestedCount,
+                truncated: false,
+                warnings,
+            };
+        }
+        const rows = db
+            .prepare(`
+        SELECT id, task_pattern, action_json, context_json, confidence, hit_count, created_at
+        FROM distilled_practices
+        ORDER BY confidence DESC, hit_count DESC, created_at DESC, id ASC
+      `)
+            .all();
+        const entries = rows.map((row) => {
+            const action = summarizeJsonField(String(row.action_json ?? ""), row.id, "action_json", warnings);
+            const context = summarizeJsonField(String(row.context_json ?? ""), row.id, "context_json", warnings);
+            return {
+                id: String(row.id),
+                taskPattern: String(row.task_pattern ?? ""),
+                confidence: Number(row.confidence ?? 0),
+                hitCount: Number(row.hit_count ?? 0),
+                createdAt: Number(row.created_at ?? 0),
+                createdAtIso: formatCreatedAt(Number(row.created_at ?? 0)),
+                actionCount: action.count,
+                actionPreview: action.preview,
+                contextCount: context.count,
+                contextPreview: context.preview,
+            };
+        });
+        return {
+            stateDir,
+            memoryDir,
+            cognitiveIndexDb,
+            entries: entries.slice(0, requestedCount),
+            totalPractices: entries.length,
+            requestedCount,
+            truncated: entries.length > requestedCount,
+            warnings,
+        };
+    }
+    catch (error) {
+        warnings.push(`cognitive_knowledge.db unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            stateDir,
+            memoryDir,
+            cognitiveIndexDb,
+            entries: [],
+            totalPractices: 0,
+            requestedCount,
+            truncated: false,
+            warnings,
+        };
+    }
+    finally {
+        db?.close();
+    }
+}
+function emptyGraphReport(stateDir, memoryDir, cognitiveIndexDb, requestedCount, warnings = []) {
+    return {
+        stateDir,
+        memoryDir,
+        cognitiveIndexDb,
+        entries: [],
+        totalNodes: 0,
+        totalEdges: 0,
+        requestedCount,
+        truncated: false,
+        warnings,
+    };
+}
+function relationLabelForNode(nodeId, edge, nodesById) {
+    if (edge.source === nodeId) {
+        const target = nodesById.get(edge.target);
+        return `${edge.relation} -> ${target?.label || edge.target}`;
+    }
+    const source = nodesById.get(edge.source);
+    return `${edge.relation} <- ${source?.label || edge.source}`;
+}
+export async function listLocalMemoryGraph(stateDir, options = {}) {
+    const requestedCount = parseMemoryReportCount(options.count);
+    const memoryDir = getMemoryDir(stateDir);
+    const cognitiveIndexDb = join(memoryDir, "cognitive_knowledge.db");
+    const warnings = [];
+    if (!(await exists(cognitiveIndexDb))) {
+        return emptyGraphReport(stateDir, memoryDir, cognitiveIndexDb, requestedCount, warnings);
+    }
+    let db = null;
+    try {
+        db = new Database(cognitiveIndexDb, { readonly: true, fileMustExist: true });
+        if (!hasTable(db, "kg_nodes") || !hasTable(db, "kg_edges")) {
+            return emptyGraphReport(stateDir, memoryDir, cognitiveIndexDb, requestedCount, warnings);
+        }
+        const nodes = db
+            .prepare("SELECT id, type, label, last_seen FROM kg_nodes")
+            .all();
+        const edges = db
+            .prepare("SELECT source, target, relation, weight FROM kg_edges")
+            .all();
+        const nodesById = new Map(nodes.map((node) => [String(node.id), node]));
+        const edgesByNode = new Map();
+        for (const edge of edges) {
+            const source = String(edge.source);
+            const target = String(edge.target);
+            edgesByNode.set(source, [...(edgesByNode.get(source) ?? []), edge]);
+            edgesByNode.set(target, [...(edgesByNode.get(target) ?? []), edge]);
+        }
+        const entries = nodes.map((node) => {
+            const id = String(node.id);
+            const relatedEdges = edgesByNode.get(id) ?? [];
+            const outgoing = relatedEdges.filter((edge) => String(edge.source) === id).length;
+            const incoming = relatedEdges.filter((edge) => String(edge.target) === id).length;
+            const preview = relatedEdges
+                .map((edge) => relationLabelForNode(id, edge, nodesById))
+                .slice(0, 3)
+                .join(" | ");
+            const lastSeen = Number(node.last_seen ?? 0);
+            return {
+                id,
+                type: String(node.type ?? "unknown"),
+                label: String(node.label ?? id),
+                lastSeen,
+                lastSeenIso: formatCreatedAt(lastSeen),
+                outgoing,
+                incoming,
+                degree: outgoing + incoming,
+                relationPreview: preview || "-",
+            };
+        });
+        entries.sort((left, right) => {
+            const timeDelta = right.lastSeen - left.lastSeen;
+            if (timeDelta !== 0)
+                return timeDelta;
+            const degreeDelta = right.degree - left.degree;
+            if (degreeDelta !== 0)
+                return degreeDelta;
+            return left.id.localeCompare(right.id);
+        });
+        return {
+            stateDir,
+            memoryDir,
+            cognitiveIndexDb,
+            entries: entries.slice(0, requestedCount),
+            totalNodes: entries.length,
+            totalEdges: edges.length,
+            requestedCount,
+            truncated: entries.length > requestedCount,
+            warnings,
+        };
+    }
+    catch (error) {
+        warnings.push(`cognitive_knowledge.db unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        return emptyGraphReport(stateDir, memoryDir, cognitiveIndexDb, requestedCount, warnings);
+    }
+    finally {
+        db?.close();
+    }
+}
+export async function findLocalMemoryEntry(stateDir, id) {
+    const memoryDir = getMemoryDir(stateDir);
+    const memoryFile = join(memoryDir, "memory.json");
+    const entries = sortEntries(await loadPersistedEntries(memoryFile, []));
+    const found = entries.find((entry) => entry.id === id);
+    return found ? toReportEntry(found) : null;
+}
+function formatCount(value) {
+    return value === null ? "unavailable" : String(value);
+}
+export function formatLocalMemoryReport(report) {
+    const lines = [
+        "",
+        "🧠 本地记忆",
+        "-----------------------------------------",
+        `State dir : ${report.stateDir}`,
+        `Memory   : ${report.memoryFile}`,
+        `Entries  : ${report.entries.length}/${report.totalEntries}`,
+        `Index    : embeddings=${formatCount(report.cognitiveIndex.embeddings)} kg_nodes=${formatCount(report.cognitiveIndex.kgNodes)} kg_edges=${formatCount(report.cognitiveIndex.kgEdges)} distilled_practices=${formatCount(report.cognitiveIndex.distilledPractices)}`,
+    ];
+    if (report.truncated) {
+        lines.push(`Limit    : 显示最近 ${report.requestedCount} 条`);
+    }
+    for (const warning of report.warnings) {
+        lines.push(`Warning  : ${warning}`);
+    }
+    if (!report.entries.length) {
+        lines.push("Status   : 暂无本地持久化记忆；继续使用轻灵后会自动沉淀，或使用现有 memory 能力写入。");
+        lines.push("-----------------------------------------");
+        lines.push("说明     : 只读取本地 memory.json 与索引表计数，不读取会话正文、不调用模型、不联网。");
+        lines.push("");
+        return lines;
+    }
+    lines.push("");
+    report.entries.forEach((entry, index) => {
+        lines.push(`${index + 1}. ${entry.id}`);
+        lines.push(`   来源     : ${entry.source}`);
+        lines.push(`   创建时间 : ${entry.createdAtIso}`);
+        lines.push(`   重要度   : ${entry.importance}`);
+        lines.push(`   预览     : ${entry.preview}`);
+    });
+    lines.push("-----------------------------------------");
+    lines.push("说明     : 列表只读取本地持久化记忆与索引元数据；用 /memory show <id> 审计单条内容。");
+    lines.push("");
+    return lines;
+}
+export function formatLocalMemorySourcesReport(report) {
+    const lines = [
+        "",
+        "🧭 本地记忆来源",
+        "-----------------------------------------",
+        `State dir : ${report.stateDir}`,
+        "",
+    ];
+    report.sources.forEach((source, index) => {
+        lines.push(`${index + 1}. ${source.id}`);
+        lines.push(`   名称     : ${source.label}`);
+        lines.push(`   路径     : ${source.path}`);
+        lines.push(`   状态     : ${source.exists ? "exists" : "missing"}`);
+        lines.push(`   角色     : ${source.role}`);
+        lines.push(`   边界     : ${source.boundary}`);
+    });
+    lines.push("-----------------------------------------");
+    lines.push("说明     : 只读检查本地来源路径是否存在；不读取 session 正文、不调用模型、不联网。");
+    lines.push("");
+    return lines;
+}
+export function formatLocalMemorySearchReport(report) {
+    const lines = [
+        "",
+        "🔎 本地记忆搜索",
+        "-----------------------------------------",
+        `Query    : ${report.query || "(empty)"}`,
+        `Memory   : ${report.memoryFile}`,
+        `Matches  : ${report.entries.length}/${report.totalMatches}`,
+        `Entries  : ${report.totalEntries}`,
+    ];
+    if (report.truncated) {
+        lines.push(`Limit    : 显示前 ${report.requestedCount} 条`);
+    }
+    for (const warning of report.warnings) {
+        lines.push(`Warning  : ${warning}`);
+    }
+    if (!report.query) {
+        lines.push("Status   : 请输入搜索词。用法: /memory search <query> [count]");
+        lines.push("-----------------------------------------");
+        lines.push("说明     : 只读取本地 memory.json，不读取会话正文、不调用模型、不联网。");
+        lines.push("");
+        return lines;
+    }
+    if (!report.entries.length) {
+        lines.push("Status   : 无本地匹配。");
+        lines.push("-----------------------------------------");
+        lines.push("说明     : 只读取本地 memory.json，不读取会话正文、不调用模型、不联网。");
+        lines.push("");
+        return lines;
+    }
+    lines.push("");
+    report.entries.forEach((entry, index) => {
+        lines.push(`${index + 1}. ${entry.id}`);
+        lines.push(`   Source    : ${entry.source}`);
+        lines.push(`   Created   : ${entry.createdAtIso}`);
+        lines.push(`   Importance: ${entry.importance}`);
+        lines.push(`   Matched via: ${entry.matchedVia.join(", ")}`);
+        lines.push(`   Preview   : ${entry.preview}`);
+    });
+    lines.push("-----------------------------------------");
+    lines.push("说明     : 搜索只输出本地记忆预览和匹配路径；用 /memory show <id> 审计完整内容。");
+    lines.push("");
+    return lines;
+}
+export function formatLocalMemoryPracticesReport(report) {
+    const lines = [
+        "",
+        "🧪 本地蒸馏实践",
+        "-----------------------------------------",
+        `DB       : ${report.cognitiveIndexDb}`,
+        `Count    : ${report.entries.length}/${report.totalPractices}`,
+    ];
+    if (report.truncated) {
+        lines.push(`Limit    : 显示前 ${report.requestedCount} 条`);
+    }
+    for (const warning of report.warnings) {
+        lines.push(`Warning  : ${warning}`);
+    }
+    if (!report.entries.length) {
+        lines.push("Status   : 暂无本地蒸馏实践。");
+        lines.push("-----------------------------------------");
+        lines.push("说明     : 只读取本地 cognitive_knowledge.db 的 distilled_practices 表，不读取会话正文、不调用模型、不联网。");
+        lines.push("");
+        return lines;
+    }
+    lines.push("");
+    report.entries.forEach((entry, index) => {
+        lines.push(`${index + 1}. ${entry.id}`);
+        lines.push(`   任务模式 : ${entry.taskPattern}`);
+        lines.push(`   置信度   : ${entry.confidence}`);
+        lines.push(`   命中次数 : ${entry.hitCount}`);
+        lines.push(`   创建时间 : ${entry.createdAtIso}`);
+        lines.push(`   动作预览 : (${entry.actionCount}) ${entry.actionPreview}`);
+        lines.push(`   上下文   : (${entry.contextCount}) ${entry.contextPreview}`);
+    });
+    lines.push("-----------------------------------------");
+    lines.push("说明     : 只读展示本地成功实践摘要；不读取 session 正文、不写入索引。");
+    lines.push("");
+    return lines;
+}
+export function formatLocalMemoryGraphReport(report) {
+    const lines = [
+        "",
+        "🕸️ 本地知识图谱",
+        "-----------------------------------------",
+        `DB       : ${report.cognitiveIndexDb}`,
+        `Nodes    : ${report.entries.length}/${report.totalNodes}`,
+        `Edges    : ${report.totalEdges}`,
+    ];
+    if (report.truncated) {
+        lines.push(`Limit    : 显示前 ${report.requestedCount} 个节点`);
+    }
+    for (const warning of report.warnings) {
+        lines.push(`Warning  : ${warning}`);
+    }
+    if (!report.entries.length) {
+        lines.push("Status   : 暂无本地知识图谱；继续使用轻灵后会自动沉淀命令、文件与任务关联。");
+        lines.push("-----------------------------------------");
+        lines.push("说明     : 只读取本地 cognitive_knowledge.db 的 kg_nodes/kg_edges 元数据，不读取会话正文、不调用模型、不联网。");
+        lines.push("");
+        return lines;
+    }
+    lines.push("");
+    report.entries.forEach((entry, index) => {
+        lines.push(`${index + 1}. ${entry.id}`);
+        lines.push(`   类型     : ${entry.type}`);
+        lines.push(`   标签     : ${entry.label}`);
+        lines.push(`   最后出现 : ${entry.lastSeenIso}`);
+        lines.push(`   连接度   : ${entry.degree} (out=${entry.outgoing}, in=${entry.incoming})`);
+        lines.push(`   关系预览 : ${entry.relationPreview}`);
+    });
+    lines.push("-----------------------------------------");
+    lines.push("说明     : 只读展示本地知识图谱节点与关系摘要；不读取 metadata、session 正文、不写入索引。");
+    lines.push("");
+    return lines;
+}
+export function formatLocalMemoryEntry(entry) {
+    if (!entry) {
+        return ["未找到指定本地记忆。"];
+    }
+    return [
+        "",
+        "🧠 本地记忆详情",
+        "-----------------------------------------",
+        `ID       : ${entry.id}`,
+        `Source   : ${entry.source}`,
+        `Created  : ${entry.createdAtIso}`,
+        `Importance: ${entry.importance}`,
+        "",
+        entry.content,
+        "-----------------------------------------",
+        "说明     : 只读取本地 memory.json 中的指定条目，不读取会话正文、不调用模型、不联网。",
+        "",
+    ];
+}