@itradingai/aiwiki 0.2.10 → 0.2.12

package/dist/src/lint.js

@@ -0,0 +1,197 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { frontmatterArray, frontmatterBoolean, frontmatterString, parseMarkdown } from "./frontmatter.js";
+import { relativePath, safeJoin } from "./paths.js";
+import { exists } from "./workspace.js";
+export async function lintWorkspace(rootPath, now = new Date().toISOString()) {
+    const root = path.resolve(rootPath);
+    const wikiEntries = await readNotes(root, "05-wiki/source-knowledge");
+    const sourceCards = await readNotes(root, "03-sources/article-cards");
+    const rawFiles = await readNotes(root, "02-raw/articles");
+    const runs = await runDirs(root);
+    const allNotes = [
+        ...wikiEntries,
+        ...sourceCards,
+        ...rawFiles,
+        ...await readNotes(root, "04-claims/_suggestions"),
+        ...await readNotes(root, "06-assets/_suggestions"),
+        ...await readNotes(root, "07-topics/ready"),
+        ...await readNotes(root, "08-outputs/outlines")
+    ];
+    const issues = [];
+    const wikiSourceCards = new Set(wikiEntries.map((note) => frontmatterString(note.frontmatter, "source_card")).filter(Boolean));
+    for (const card of sourceCards) {
+        if (!wikiSourceCards.has(card.path)) {
+            issues.push({
+                severity: "warning",
+                path: card.path,
+                message: "Source Card 没有对应 Wiki Entry。",
+                suggestion: `重新入库或生成 05-wiki/source-knowledge/${path.basename(card.path)}`
+            });
+        }
+    }
+    for (const entry of wikiEntries) {
+        const sourceCard = frontmatterString(entry.frontmatter, "source_card");
+        const rawFile = frontmatterString(entry.frontmatter, "raw_file");
+        const mode = frontmatterString(entry.frontmatter, "generation_mode");
+        if (!sourceCard) {
+            issues.push({ severity: "warning", path: entry.path, message: "Wiki Entry 缺少 source_card。", suggestion: "补写 source_card vault 路径。" });
+        }
+        if (!rawFile) {
+            issues.push({ severity: "warning", path: entry.path, message: "Wiki Entry 缺少 raw_file。", suggestion: "补写 raw_file vault 路径。" });
+        }
+        if (mode === "deterministic_fallback") {
+            issues.push({ severity: "info", path: entry.path, message: "Wiki Entry 是 deterministic fallback，仅包含来源和正文预览。", suggestion: "让宿主 Agent 基于原文补充 analysis 或 wiki_entry。" });
+            const createdAt = Date.parse(frontmatterString(entry.frontmatter, "created_at") ?? "");
+            if (Number.isFinite(createdAt) && Date.parse(now) - createdAt > 7 * 24 * 60 * 60 * 1000) {
+                issues.push({ severity: "warning", path: entry.path, message: "fallback Wiki Entry 超过 7 天未补全。", suggestion: "重新运行宿主 Agent 生成 enriched Wiki Entry。" });
+            }
+        }
+        if (mode === "agent_enriched") {
+            const hasSummary = /## 一句话总结/.test(entry.body) || Boolean(frontmatterString(entry.frontmatter, "summary"));
+            const hasKeyPoints = /## 核心观点[\s\S]*-\s+/.test(entry.body);
+            if (!hasSummary) {
+                issues.push({ severity: "warning", path: entry.path, message: "agent_enriched Wiki Entry 缺少 summary。", suggestion: "让宿主 Agent 提供 analysis.summary。" });
+            }
+            if (!hasKeyPoints) {
+                issues.push({ severity: "warning", path: entry.path, message: "agent_enriched Wiki Entry 缺少 key_points。", suggestion: "让宿主 Agent 提供 analysis.key_points。" });
+            }
+        }
+        if (frontmatterBoolean(entry.frontmatter, "grounding_needs_review") === true) {
+            const markers = frontmatterArray(entry.frontmatter, "grounding_markers");
+            issues.push({
+                severity: "warning",
+                path: entry.path,
+                message: `Wiki Entry 需要 grounding 复核${markers.length ? `: ${markers.join(", ")}` : "。"}`,
+                suggestion: "检查 source_quote 是否能在 Raw 中找到；coverage_suspected_incomplete 仅代表启发式疑似风险。"
+            });
+        }
+        if (frontmatterBoolean(entry.frontmatter, "represents_user_view") === true && frontmatterString(entry.frontmatter, "source_role") !== "output") {
+            issues.push({ severity: "warning", path: entry.path, message: "只有 output 角色应标记为代表用户观点。", suggestion: "将 represents_user_view 改为 false，或将 source_role 改为 output。" });
+        }
+    }
+    issues.push(...duplicateIssues(sourceCards, "source_url", "重复 URL"));
+    issues.push(...duplicateTitles(allNotes));
+    issues.push(...brokenLinkIssues(root, allNotes));
+    return {
+        generated_at: now,
+        summary: {
+            wiki_entries: wikiEntries.length,
+            source_cards: sourceCards.length,
+            raw_files: rawFiles.length,
+            runs: runs.length
+        },
+        issues
+    };
+}
+export async function writeLintReport(rootPath, report) {
+    const root = path.resolve(rootPath);
+    const target = safeJoin(root, "dashboards", "Lint Report.md");
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, renderLintReport(report), "utf8");
+    return relativePath(root, target);
+}
+export function renderLintReport(report) {
+    return [
+        "# AIWiki Lint Report",
+        "",
+        `Generated at: ${report.generated_at}`,
+        "",
+        "## Summary",
+        "",
+        `- Wiki Entries: ${report.summary.wiki_entries}`,
+        `- Source Cards: ${report.summary.source_cards}`,
+        `- Raw Files: ${report.summary.raw_files}`,
+        `- Runs: ${report.summary.runs}`,
+        "",
+        "## Issues",
+        "",
+        ...(report.issues.length ? report.issues.map((issue) => {
+            const suffix = issue.path ? ` (${issue.path})` : "";
+            const suggestion = issue.suggestion ? `\n  - Suggested Fix: ${issue.suggestion}` : "";
+            return `- [${issue.severity}] ${issue.message}${suffix}${suggestion}`;
+        }) : ["- none"]),
+        ""
+    ].join("\n");
+}
+async function readNotes(root, dir) {
+    const absolute = path.join(root, dir);
+    if (!(await exists(absolute))) {
+        return [];
+    }
+    const files = await listMarkdownFiles(absolute);
+    return Promise.all(files.map(async (file) => {
+        const text = await fs.readFile(file, "utf8");
+        const parsed = parseMarkdown(text);
+        return {
+            path: relativePath(root, file),
+            title: frontmatterString(parsed.frontmatter, "title") ?? path.basename(file, ".md"),
+            sourceUrl: frontmatterString(parsed.frontmatter, "source_url") ?? "",
+            body: parsed.body,
+            frontmatter: parsed.frontmatter
+        };
+    }));
+}
+async function runDirs(root) {
+    const dir = path.join(root, "09-runs");
+    if (!(await exists(dir))) {
+        return [];
+    }
+    return (await fs.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+async function listMarkdownFiles(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const target = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await listMarkdownFiles(target));
+        }
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+            files.push(target);
+        }
+    }
+    return files;
+}
+function duplicateIssues(notes, field, label) {
+    const seen = new Map();
+    for (const note of notes) {
+        const value = field === "source_url" ? note.sourceUrl : "";
+        if (!value) {
+            continue;
+        }
+        seen.set(value, [...(seen.get(value) ?? []), note.path]);
+    }
+    return Array.from(seen.entries()).flatMap(([value, paths]) => paths.length > 1
+        ? [{ severity: "warning", message: `${label}: ${value}`, suggestion: paths.join(", ") }]
+        : []);
+}
+function duplicateTitles(notes) {
+    const seen = new Map();
+    for (const note of notes) {
+        if (!note.title) {
+            continue;
+        }
+        seen.set(note.title, [...(seen.get(note.title) ?? []), note.path]);
+    }
+    return Array.from(seen.entries()).flatMap(([title, paths]) => paths.length > 1
+        ? [{ severity: "info", message: `重复标题: ${title}`, suggestion: paths.join(", ") }]
+        : []);
+}
+function brokenLinkIssues(root, notes) {
+    const existing = new Set(notes.map((note) => note.path.replace(/\.md$/i, "")));
+    const issues = [];
+    for (const note of notes) {
+        for (const link of note.body.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g)) {
+            const target = link[1].replace(/\\/g, "/").replace(/\.md$/i, "");
+            if (!existing.has(target) && !isRunLocalLink(target)) {
+                issues.push({ severity: "error", path: note.path, message: `内部链接断裂: ${target}`, suggestion: "检查目标文件是否存在或更新 wikilink。" });
+            }
+        }
+    }
+    return issues;
+}
+function isRunLocalLink(target) {
+    // Run-local notes are valid trace links but are not part of the long-term note set.
+    return target.startsWith("09-runs/");
+}

package/dist/src/payload.js

@@ -35,12 +35,14 @@ export function normalizePayload(raw, runStartedAt) {
     if (!kind) {
         throw new Error("source.kind is required");
     }
+    const sourceRole = normalizeSourceRole(stringValue(sourceRaw.source_role) ?? stringValue(sourceRaw.role), warnings);
+    const representsUserView = booleanValue(sourceRaw.represents_user_view) ?? sourceRole === "output";
     const requestRaw = isRecord(raw.request) ? raw.request : {};
     const requestedOutputs = Array.isArray(requestRaw.outputs)
         ? requestRaw.outputs.filter((item) => typeof item === "string")
         : ["source_card", "creative_assets", "topics", "draft_outline", "processing_summary"];
-    const outputs = ["source_card", "creative_assets", "topics", "draft_outline", "processing_summary"];
-    if (fetchStatus !== "failed" && requestedOutputs.length && requestedOutputs.length !== outputs.length) {
+    const outputs = ["source_card", "wiki_entry", "creative_assets", "topics", "draft_outline", "processing_summary"];
+    if (fetchStatus !== "failed" && requestedOutputs.length && hasCustomOutputRequest(requestedOutputs)) {
         warnings.push("AIWiki 会为每条输入生成完整资料产物，request.outputs 已按全量输出处理。");
     }
     if (typeof raw.target_kb === "string" && raw.target_kb.trim()) {
@@ -55,6 +57,8 @@ export function normalizePayload(raw, runStartedAt) {
     if (fetchNotesRepair.repaired) {
         warnings.push("source.fetch_notes 检测到疑似 UTF-8 mojibake，已自动修复。");
     }
+    const analysis = normalizeAnalysis(raw.analysis, warnings);
+    const wikiEntry = normalizeWikiEntry(raw.wiki_entry, warnings);
     if (fetchStatus === "failed" && content?.trim()) {
         throw new Error("source.content must be empty when source.fetch_status is failed");
     }
@@ -63,6 +67,8 @@ export function normalizePayload(raw, runStartedAt) {
         target_kb: stringValue(raw.target_kb),
         source: {
             kind,
+            source_role: sourceRole,
+            represents_user_view: representsUserView,
             url: stringValue(sourceRaw.url),
             title: titleRepair.value,
             author: stringValue(sourceRaw.author),
@@ -80,9 +86,21 @@ export function normalizePayload(raw, runStartedAt) {
             outputs,
             language: stringValue(requestRaw.language) ?? stringValue(sourceRaw.language)
         },
+        analysis,
+        wiki_entry: wikiEntry,
         warnings
     };
 }
+function normalizeSourceRole(value, warnings) {
+    if (!value) {
+        return "input";
+    }
+    if (value === "input" || value === "processing" || value === "output") {
+        return value;
+    }
+    warnings.push(`source_role 已忽略：${value} 不是 input、processing 或 output。`);
+    return "input";
+}
 function normalizeFetchStatus(value, content) {
     if (value === "failed") {
         return "failed";
@@ -99,10 +117,150 @@ function rejectWriteControlFields(raw) {
     if (typeof raw.output_file === "string") {
         throw new Error("payload must not control output paths");
     }
+    if (isRecord(raw.wiki_entry) && typeof raw.wiki_entry.path === "string") {
+        throw new Error("payload must not control output paths");
+    }
 }
 function stringValue(value) {
     return typeof value === "string" ? value : undefined;
 }
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function normalizeAnalysis(value, warnings) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        warnings.push("analysis 已忽略：必须是对象。");
+        return undefined;
+    }
+    const analysis = {
+        summary: stringValue(value.summary),
+        key_points: stringArray(value.key_points, "analysis.key_points", warnings),
+        reusable_knowledge: reusableKnowledgeArray(value.reusable_knowledge, warnings),
+        related_concepts: stringArray(value.related_concepts, "analysis.related_concepts", warnings),
+        use_cases: stringArray(value.use_cases, "analysis.use_cases", warnings),
+        topic_candidates: stringArray(value.topic_candidates, "analysis.topic_candidates", warnings),
+        claims: claimsArray(value.claims, warnings),
+        outline: outlineValue(value.outline, warnings)
+    };
+    return hasAnalysisContent(analysis) ? analysis : undefined;
+}
+function normalizeWikiEntry(value, warnings) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        warnings.push("wiki_entry 已忽略：必须是对象。");
+        return undefined;
+    }
+    const entry = {
+        title: stringValue(value.title),
+        summary: stringValue(value.summary),
+        sections: wikiSections(value.sections, warnings),
+        markdown: stringValue(value.markdown)
+    };
+    return entry.title || entry.summary || entry.sections.length || entry.markdown ? entry : undefined;
+}
+function stringArray(value, field, warnings) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        warnings.push(`${field} 已忽略：必须是字符串数组。`);
+        return [];
+    }
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function reusableKnowledgeArray(value, warnings) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        warnings.push("analysis.reusable_knowledge 已忽略：必须是数组。");
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (typeof item === "string" && item.trim()) {
+            return [{ content: item.trim() }];
+        }
+        if (isRecord(item) && typeof item.content === "string" && item.content.trim()) {
+            return [{ title: stringValue(item.title), content: item.content.trim(), source_quote: stringValue(item.source_quote) }];
+        }
+        return [];
+    });
+}
+function claimsArray(value, warnings) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        warnings.push("analysis.claims 已忽略：必须是数组。");
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (typeof item === "string" && item.trim()) {
+            return [{ claim: item.trim() }];
+        }
+        if (isRecord(item) && typeof item.claim === "string" && item.claim.trim()) {
+            return [{
+                    claim: item.claim.trim(),
+                    confidence: stringValue(item.confidence),
+                    source_quote: stringValue(item.source_quote)
+                }];
+        }
+        return [];
+    });
+}
+function outlineValue(value, warnings) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        warnings.push("analysis.outline 已忽略：必须是对象。");
+        return undefined;
+    }
+    const sections = stringArray(value.sections, "analysis.outline.sections", warnings);
+    if (!sections.length && !stringValue(value.title)) {
+        return undefined;
+    }
+    return { title: stringValue(value.title), sections };
+}
+function wikiSections(value, warnings) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        warnings.push("wiki_entry.sections 已忽略：必须是数组。");
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (!isRecord(item) || typeof item.heading !== "string" || !item.heading.trim()) {
+            return [];
+        }
+        return [{
+                heading: item.heading.trim(),
+                items: stringArray(item.items, "wiki_entry.sections.items", warnings)
+            }];
+    });
+}
+function hasAnalysisContent(analysis) {
+    return Boolean(analysis.summary ||
+        analysis.key_points.length ||
+        analysis.reusable_knowledge.length ||
+        analysis.related_concepts.length ||
+        analysis.use_cases.length ||
+        analysis.topic_candidates.length ||
+        analysis.claims.length ||
+        analysis.outline);
+}
+function hasCustomOutputRequest(outputs) {
+    const legacyDefault = ["source_card", "creative_assets", "topics", "draft_outline", "processing_summary"];
+    const currentDefault = ["source_card", "wiki_entry", "creative_assets", "topics", "draft_outline", "processing_summary"];
+    const sameSet = (left, right) => left.length === right.length && left.every((item) => right.includes(item));
+    return !sameSet(outputs, legacyDefault) && !sameSet(outputs, currentDefault);
+}

package/dist/src/wiki-entry.js

@@ -0,0 +1,180 @@
+import { buildGroundingReport, groundingFrontmatterLines } from "./grounding.js";
+export function renderWikiEntry(payload, links) {
+    const enriched = Boolean(payload.wiki_entry || payload.analysis);
+    const mode = enriched ? "agent_enriched" : "deterministic_fallback";
+    const quality = enriched ? "enriched" : "scaffold";
+    const title = payload.wiki_entry?.title ?? payload.source.title ?? "Untitled";
+    const grounding = buildGroundingReport(payload);
+    const frontmatter = wikiFrontmatter(payload, links, title, mode, quality, grounding);
+    const body = enriched ? enrichedBody(payload, links, title, grounding) : fallbackBody(payload, links, title, grounding);
+    return {
+        mode,
+        quality,
+        markdown: `${frontmatter}\n${body}`
+    };
+}
+function wikiFrontmatter(payload, links, title, mode, quality, grounding) {
+    return [
+        "---",
+        `aiwiki_id: "${escapeYaml(`${links.slug}:wiki-entry`)}"`,
+        `type: "wiki_entry"`,
+        `wiki_type: "${wikiType(payload)}"`,
+        `source_role: "${payload.source.source_role}"`,
+        `represents_user_view: ${payload.source.represents_user_view ? "true" : "false"}`,
+        `status: "active"`,
+        `generation_mode: "${mode}"`,
+        `quality: "${quality}"`,
+        `generated_by: "${mode === "agent_enriched" ? "host_agent" : "aiwiki_cli"}"`,
+        `llm_enriched: ${mode === "agent_enriched" ? "true" : "false"}`,
+        `title: "${escapeYaml(title)}"`,
+        `slug: "${escapeYaml(links.slug)}"`,
+        `source_url: "${escapeYaml(payload.source.url ?? "")}"`,
+        `source_type: "${escapeYaml(payload.source.kind)}"`,
+        `source_card: "${escapeYaml(links.sourceCard)}"`,
+        `raw_file: "${escapeYaml(links.raw)}"`,
+        `claims_file: "${escapeYaml(links.claims)}"`,
+        `topics_file: "${escapeYaml(links.topics)}"`,
+        `outline_file: "${escapeYaml(links.outline)}"`,
+        `run_summary: "${escapeYaml(links.runSummary)}"`,
+        `run_id: "${escapeYaml(links.runId)}"`,
+        `created_at: "${escapeYaml(links.createdAt)}"`,
+        `updated_at: "${escapeYaml(links.createdAt)}"`,
+        ...(mode === "agent_enriched" ? [`summary: "${escapeYaml(payload.wiki_entry?.summary ?? payload.analysis?.summary ?? "")}"`] : []),
+        `topics: ${yamlStringArray(payload.analysis?.related_concepts ?? [])}`,
+        `claims: ${yamlStringArray(payload.analysis?.claims.map((claim) => claim.claim) ?? [])}`,
+        ...groundingFrontmatterLines(grounding),
+        `tags: ["aiwiki/wiki-entry"]`,
+        "---"
+    ].join("\n");
+}
+function wikiType(payload) {
+    if (payload.source.source_role === "output") {
+        return "personal_knowledge";
+    }
+    if (payload.source.source_role === "processing") {
+        return "thought_note";
+    }
+    return "source_knowledge";
+}
+function enrichedBody(payload, links, title, grounding) {
+    const sections = [`# ${title}`, ""];
+    appendGroundingReview(sections, grounding);
+    if (payload.wiki_entry?.summary || payload.analysis?.summary) {
+        sections.push("## 一句话总结", "", payload.wiki_entry?.summary ?? payload.analysis?.summary ?? "", "");
+    }
+    if (payload.wiki_entry?.markdown?.trim()) {
+        sections.push(payload.wiki_entry.markdown.trim(), "");
+        if (payload.wiki_entry.sections.length) {
+            for (const section of payload.wiki_entry.sections) {
+                if (bodyHasHeading(payload.wiki_entry.markdown, section.heading)) {
+                    continue;
+                }
+                sections.push(`## ${section.heading}`, "", ...listOrFallback(section.items, "待宿主 Agent 补充。"), "");
+            }
+        }
+        sections.push(sourceSection(links));
+        return sections.join("\n");
+    }
+    if (payload.wiki_entry?.sections.length) {
+        for (const section of payload.wiki_entry.sections) {
+            sections.push(`## ${section.heading}`, "", ...listOrFallback(section.items, "待宿主 Agent 补充。"), "");
+        }
+    }
+    else {
+        sections.push("## 核心观点", "", ...listOrFallback(payload.analysis?.key_points ?? [], "待宿主 Agent 补充。"), "");
+        sections.push("## 可复用知识点", "", ...knowledgeList(payload), "");
+        sections.push("## 相关概念", "", ...listOrFallback(payload.analysis?.related_concepts ?? [], "待宿主 Agent 补充。"), "");
+        sections.push("## 适合用于什么场景", "", ...listOrFallback(payload.analysis?.use_cases ?? [], "待宿主 Agent 补充。"), "");
+        sections.push("## 可转化的选题", "", ...listOrFallback(payload.analysis?.topic_candidates ?? [], "待宿主 Agent 补充。"), "");
+    }
+    sections.push(sourceSection(links));
+    return sections.join("\n");
+}
+function bodyHasHeading(markdown, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`^#{1,6}\\s+${escaped}\\s*$`, "m").test(markdown);
+}
+function fallbackBody(payload, links, title, grounding) {
+    const preview = trimPreview(payload.source.content ?? payload.source.fetch_notes ?? "", 1000);
+    return [
+        `# ${title}`,
+        "",
+        "## 说明",
+        "",
+        "这是 AIWiki 根据原文和元数据生成的基础 Wiki 条目。当前条目未经过宿主 Agent 的深度分析，仅用于建立知识库索引、来源追踪和后续 Query。",
+        "",
+        "## 来源信息",
+        "",
+        `- 原文链接：${payload.source.url ?? "无"}`,
+        `- Source Card：${obsidianLink(links.sourceCard, "资料卡")}`,
+        `- Raw：${obsidianLink(links.raw, "原文")}`,
+        `- Run：${obsidianLink(links.runSummary, "处理记录")}`,
+        "",
+        "## 内容预览",
+        "",
+        preview ? blockquote(preview) : "暂无可用正文预览。",
+        "",
+        "## 待 Agent 补全",
+        "",
+        "以下内容需要宿主 Agent 基于原文进一步生成：",
+        "",
+        "- 一句话总结",
+        "- 核心观点",
+        "- 可复用知识点",
+        "- 相关概念",
+        "- 适用场景",
+        "- 可转化选题",
+        "",
+        ...groundingReviewLines(grounding),
+        "",
+        sourceSection(links)
+    ].join("\n");
+}
+function knowledgeList(payload) {
+    const items = payload.analysis?.reusable_knowledge ?? [];
+    if (!items.length) {
+        return ["待宿主 Agent 补充。"];
+    }
+    return items.flatMap((item) => item.title ? [`### ${item.title}`, "", item.content] : [`- ${item.content}`]);
+}
+function listOrFallback(values, fallback) {
+    return values.length ? values.map((value) => `- ${value}`) : [fallback];
+}
+function sourceSection(links) {
+    return [
+        "## 来源",
+        "",
+        `- Source Card: ${obsidianLink(links.sourceCard, "资料卡")}`,
+        `- Raw: ${obsidianLink(links.raw, "原文")}`,
+        `- Run: ${obsidianLink(links.runSummary, "处理记录")}`
+    ].join("\n");
+}
+function appendGroundingReview(sections, grounding) {
+    if (!grounding.needs_review) {
+        return;
+    }
+    sections.push("## Grounding 复核", "", ...groundingReviewLines(grounding), "");
+}
+function groundingReviewLines(grounding) {
+    return [
+        `- 证据通道：${grounding.evidence_channel}`,
+        `- 需要复核：${grounding.needs_review ? "yes" : "no"}`,
+        `- 疑似标记：${grounding.suspicion_markers.length ? grounding.suspicion_markers.join(", ") : "none"}`,
+        `- Claim 引用覆盖：${grounding.claim_quote_count}/${grounding.claim_count}`
+    ];
+}
+function obsidianLink(vaultPath, label) {
+    return `[[${vaultPath.replace(/\\/g, "/").replace(/\.md$/i, "")}|${label}]]`;
+}
+function blockquote(value) {
+    return value.split(/\r?\n/).map((line) => `> ${line}`).join("\n");
+}
+function trimPreview(value, length) {
+    return value.replace(/\s+/g, " ").trim().slice(0, length);
+}
+function yamlStringArray(values) {
+    return `[${values.map((value) => `"${escapeYaml(value)}"`).join(", ")}]`;
+}
+function escapeYaml(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}

package/dist/src/workspace.js

@@ -10,6 +10,7 @@ export const REQUIRED_DIRS = [
     "03-sources/article-cards",
     "04-claims/_suggestions",
     "05-wiki",
+    "05-wiki/source-knowledge",
     "06-assets/_suggestions",
     "07-topics/ready",
     "08-outputs/outlines",
@@ -28,9 +29,12 @@ AIWiki 的 Obsidian 入口。Dataview 是可选增强；未安装时仍可使用
 
 ## 原生链接入口
 
+- [[dashboards/Wiki Entries|Wiki 条目]]
+- [[dashboards/Source Cards|资料卡]]
 - [[dashboards/Review Queue|待审队列]]
 - [[dashboards/Recent Runs|最近处理]]
 - [[dashboards/Topic Pipeline|选题管线]]
+- [[dashboards/Lint Report|结构检查]]
 - [[_system/schemas/aiwiki-frontmatter|字段说明]]
 
 ## 最近收录
@@ -50,6 +54,34 @@ FROM "03-sources/article-cards" or "04-claims/_suggestions" or "06-assets/_sugge
 WHERE status = "to-review"
 SORT created_at DESC
 \`\`\`
+`
+    },
+    {
+        path: "dashboards/Wiki Entries.md",
+        content: `# Wiki 条目
+
+AIWiki 每次成功入库都会生成 Wiki Entry。这里是知识层入口，不要求先经过 Review Queue 才能查询。
+
+\`\`\`dataview
+TABLE wiki_type, source_role, represents_user_view, quality, source_card, raw_file, updated_at
+FROM "05-wiki"
+WHERE type = "wiki_entry"
+SORT updated_at DESC
+\`\`\`
+`
+    },
+    {
+        path: "dashboards/Source Cards.md",
+        content: `# 资料卡
+
+资料卡用于追踪来源、原文、Claim 建议、素材建议、选题和大纲。
+
+\`\`\`dataview
+TABLE status, source_url, wiki_entry, raw_note, captured_at
+FROM "03-sources/article-cards"
+WHERE type = "source_card"
+SORT captured_at DESC
+\`\`\`
 `
     },
     {