@itradingai/aiwiki 0.2.16 → 0.2.19

package/dist/src/context.js

@@ -11,13 +11,28 @@ const GROUPS = [
     { key: "outlines", dir: "08-outputs/outlines", weight: 2 },
     { key: "raw_refs", dir: "02-raw/articles", weight: 1 }
 ];
-export async function buildContext(rootPath, query, now = new Date().toISOString()) {
+const DEFAULT_LIMIT = 10;
+export async function buildContext(rootPath, query, options = {}, now = new Date().toISOString()) {
     const root = path.resolve(rootPath);
     const tokens = tokenize(query);
+    const limit = normalizeLimit(options.limit);
+    const filters = normalizeFilters(options.filters);
     const result = {
         schema_version: "aiwiki.context.v1",
         query,
         generated_at: now,
+        query_scope: {
+            filters,
+            limit,
+            searched_groups: []
+        },
+        result_quality: {
+            total_matches: 0,
+            best_score: 0,
+            has_wiki_entry: false,
+            warnings: []
+        },
+        recommended_next_action: "broaden_query",
         matches: {
             wiki_entries: [],
             source_cards: [],
@@ -26,34 +41,41 @@ export async function buildContext(rootPath, query, now = new Date().toISOString
             outlines: [],
             raw_refs: []
         },
-        suggested_answer_structure: ["主题概览", "核心观点", "已有资料依据", "可复用判断", "下一步建议"],
+        suggested_answer_structure: ["topic overview", "core claims", "available evidence", "reuse judgment", "next action"],
         warnings: []
     };
     if (!tokens.length) {
         result.warnings.push("query is empty after tokenization");
+        finalizeQuality(result);
         return result;
     }
     for (const group of GROUPS.filter((item) => item.key !== "raw_refs")) {
+        if (!groupAllowed(group.key, filters.type)) {
+            continue;
+        }
         const dir = path.join(root, group.dir);
         if (!(await exists(dir))) {
             continue;
         }
-        const matches = await searchDir(root, dir, tokens, group.weight);
-        result.matches[group.key].push(...matches.slice(0, 10));
+        result.query_scope.searched_groups.push(group.key);
+        const matches = await searchDir(root, dir, tokens, group.weight, group.key, filters);
+        result.matches[group.key].push(...matches.slice(0, limit));
     }
-    if (!result.matches.wiki_entries.length) {
-        result.warnings.push("未命中 Wiki Entry，结果可能来自资料卡、选题或原文引用。");
+    if (!result.matches.wiki_entries.length && groupAllowed("raw_refs", filters.type)) {
+        result.warnings.push("No Wiki Entry matched; results may come from source cards, topics, outlines, or raw references.");
         const rawGroup = GROUPS.find((item) => item.key === "raw_refs");
         if (rawGroup) {
             const rawDir = path.join(root, rawGroup.dir);
             if (await exists(rawDir)) {
-                result.matches.raw_refs.push(...(await searchDir(root, rawDir, tokens, rawGroup.weight)).slice(0, 10));
+                result.query_scope.searched_groups.push(rawGroup.key);
+                result.matches.raw_refs.push(...(await searchDir(root, rawDir, tokens, rawGroup.weight, rawGroup.key, filters)).slice(0, limit));
             }
         }
     }
+    finalizeQuality(result);
     return result;
 }
-async function searchDir(root, dir, tokens, weight) {
+async function searchDir(root, dir, tokens, weight, groupKey, filters) {
     const files = await listMarkdownFiles(dir);
     const matches = [];
     for (const file of files) {
@@ -61,12 +83,24 @@ async function searchDir(root, dir, tokens, weight) {
         const parsed = parseMarkdown(text);
         const rel = relativePath(root, file);
         const title = frontmatterString(parsed.frontmatter, "title") ?? path.basename(file, ".md");
+        const type = frontmatterString(parsed.frontmatter, "type") ?? groupKey;
+        const status = frontmatterString(parsed.frontmatter, "status");
+        const sourceRole = frontmatterString(parsed.frontmatter, "source_role");
+        const wikiType = frontmatterString(parsed.frontmatter, "wiki_type");
+        if (!passesFilters({ type, groupKey, status, source_role: sourceRole, wiki_type: wikiType }, filters)) {
+            continue;
+        }
+        const topics = frontmatterArray(parsed.frontmatter, "topics");
+        const tags = frontmatterArray(parsed.frontmatter, "tags");
+        const relatedRefs = relatedReferences(parsed.frontmatter, parsed.body);
+        const sourceUrl = frontmatterString(parsed.frontmatter, "source_url") ?? "";
         const haystack = [
             rel,
             title,
-            frontmatterString(parsed.frontmatter, "source_url") ?? "",
-            frontmatterArray(parsed.frontmatter, "topics").join(" "),
-            frontmatterArray(parsed.frontmatter, "tags").join(" "),
+            sourceUrl,
+            topics.join(" "),
+            tags.join(" "),
+            relatedRefs.join(" "),
             parsed.body
         ].join("\n").toLowerCase();
         const hits = tokens.filter((token) => haystack.includes(token.toLowerCase())).length;
@@ -77,8 +111,9 @@ async function searchDir(root, dir, tokens, weight) {
         const quality = frontmatterString(parsed.frontmatter, "quality");
         const groundingMarkers = frontmatterArray(parsed.frontmatter, "grounding_markers");
         const groundingNeedsReview = frontmatterBoolean(parsed.frontmatter, "grounding_needs_review");
+        const groundingEvidenceAvailable = frontmatterBoolean(parsed.frontmatter, "grounding_evidence_available");
         const warnings = generationMode === "deterministic_fallback"
-            ? ["该 Wiki Entry 是 deterministic fallback，仅包含来源、正文预览和待补全区。"]
+            ? ["This Wiki Entry is a deterministic fallback; it may need host-agent enrichment."]
             : [];
         if (groundingNeedsReview) {
             warnings.push(`Grounding needs review${groundingMarkers.length ? `: ${groundingMarkers.join(", ")}` : ""}.`);
@@ -88,11 +123,19 @@ async function searchDir(root, dir, tokens, weight) {
             path: rel,
             summary: frontmatterString(parsed.frontmatter, "summary") ?? summarize(parsed.body, quality),
             score: Number(((hits / tokens.length) * weight).toFixed(2)),
-            topics: frontmatterArray(parsed.frontmatter, "topics"),
-            source_url: frontmatterString(parsed.frontmatter, "source_url") ?? "",
+            type,
+            topics,
+            tags,
+            source_url: sourceUrl,
+            status,
+            source_role: sourceRole,
+            wiki_type: wikiType,
+            match_reasons: matchReasons(tokens, { rel, title, body: parsed.body, topics, tags, relatedRefs, sourceUrl }),
+            quality_signals: qualitySignals({ quality, generationMode, groundingEvidenceAvailable, groundingNeedsReview, status, relatedRefs }),
+            related_refs: relatedRefs,
             generation_mode: generationMode,
             quality,
-            grounding_evidence_available: frontmatterBoolean(parsed.frontmatter, "grounding_evidence_available"),
+            grounding_evidence_available: groundingEvidenceAvailable,
             grounding_needs_review: groundingNeedsReview,
             grounding_markers: groundingMarkers,
             warnings
@@ -125,7 +168,121 @@ function tokenize(value) {
 function summarize(body, quality) {
     const compact = body.replace(/\s+/g, " ").trim();
     if (quality === "scaffold") {
-        return "仅有正文预览，未生成高质量摘要。";
+        return "Only a scaffold preview is available; enrich before relying on it as a final answer.";
     }
     return compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
 }
+function normalizeLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_LIMIT;
+    }
+    return Math.max(1, Math.min(50, Math.floor(value)));
+}
+function normalizeFilters(filters) {
+    return Object.fromEntries(Object.entries(filters ?? {})
+        .filter(([, value]) => typeof value === "string" && value.trim())
+        .map(([key, value]) => [key, String(value).trim()]));
+}
+function groupAllowed(groupKey, typeFilter) {
+    if (!typeFilter) {
+        return true;
+    }
+    return normalizeType(typeFilter) === normalizeType(groupKey);
+}
+function passesFilters(item, filters) {
+    if (filters.type && normalizeType(filters.type) !== normalizeType(item.type) && normalizeType(filters.type) !== normalizeType(item.groupKey)) {
+        return false;
+    }
+    if (filters.status && filters.status !== item.status) {
+        return false;
+    }
+    if (filters.source_role && filters.source_role !== item.source_role) {
+        return false;
+    }
+    if (filters.wiki_type && filters.wiki_type !== item.wiki_type) {
+        return false;
+    }
+    return true;
+}
+function normalizeType(value) {
+    return value.replace(/-/g, "_").toLowerCase();
+}
+function relatedReferences(frontmatter, body) {
+    const refs = [
+        frontmatterString(frontmatter, "source_card"),
+        frontmatterString(frontmatter, "raw_file"),
+        frontmatterString(frontmatter, "claims_note"),
+        frontmatterString(frontmatter, "assets_note"),
+        frontmatterString(frontmatter, "topics_note"),
+        frontmatterString(frontmatter, "outline_note"),
+        ...extractWikilinks(body)
+    ].filter((value) => Boolean(value));
+    return Array.from(new Set(refs));
+}
+function extractWikilinks(body) {
+    const refs = [];
+    const pattern = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+    for (const match of body.matchAll(pattern)) {
+        refs.push(match[1].trim());
+    }
+    return refs;
+}
+function matchReasons(tokens, fields) {
+    const reasons = new Set();
+    for (const token of tokens.map((item) => item.toLowerCase())) {
+        if (fields.title.toLowerCase().includes(token))
+            reasons.add("title");
+        if (fields.rel.toLowerCase().includes(token))
+            reasons.add("path");
+        if (fields.sourceUrl.toLowerCase().includes(token))
+            reasons.add("source_url");
+        if (fields.topics.join(" ").toLowerCase().includes(token))
+            reasons.add("topics");
+        if (fields.tags.join(" ").toLowerCase().includes(token))
+            reasons.add("tags");
+        if (fields.relatedRefs.join(" ").toLowerCase().includes(token))
+            reasons.add("relationships");
+        if (fields.body.toLowerCase().includes(token))
+            reasons.add("body");
+    }
+    return Array.from(reasons);
+}
+function qualitySignals(item) {
+    const signals = [];
+    if (item.quality)
+        signals.push(`quality:${item.quality}`);
+    if (item.status)
+        signals.push(`status:${item.status}`);
+    if (item.generationMode)
+        signals.push(`generation_mode:${item.generationMode}`);
+    if (item.groundingEvidenceAvailable === true)
+        signals.push("grounding:evidence_available");
+    if (item.groundingEvidenceAvailable === false)
+        signals.push("grounding:no_evidence_flag");
+    if (item.groundingNeedsReview)
+        signals.push("grounding:needs_review");
+    if (item.relatedRefs.length)
+        signals.push("relationships:present");
+    return signals;
+}
+function finalizeQuality(result) {
+    const all = Object.values(result.matches).flat();
+    result.result_quality = {
+        total_matches: all.length,
+        best_score: all.reduce((best, item) => Math.max(best, item.score), 0),
+        has_wiki_entry: result.matches.wiki_entries.length > 0,
+        warnings: result.warnings
+    };
+    if (!all.length) {
+        result.recommended_next_action = "broaden_query_or_ingest_source";
+    }
+    else if (!result.matches.wiki_entries.length) {
+        result.recommended_next_action = "review_source_cards_then_create_wiki_entry";
+    }
+    else if (all.some((item) => item.grounding_needs_review || item.quality === "scaffold")) {
+        result.recommended_next_action = "review_grounding_or_enrich_entry";
+    }
+    else {
+        result.recommended_next_action = "use_matches_for_answer";
+    }
+}

package/dist/src/ingest.js

@@ -30,23 +30,38 @@ export async function ingestPayload(rootPath, rawPayload) {
     const contentFingerprint = createContentFingerprint(content);
     const collisionWarnings = [];
     await detectDuplicateContent(root, payload, contentFingerprint, collisionWarnings);
-    const longTermTargets = await chooseLongTermTargets(root, slug, runId, collisionWarnings);
+    const optionalOutputs = optionalOutputPlan(payload);
+    const longTermTargets = await chooseLongTermTargets(root, slug, runId, collisionWarnings, optionalOutputs);
     const links = buildArtifactLinks(root, slug, runDirName, runStartedAt, contentFingerprint, longTermTargets);
     const grounding = buildGroundingReport(payload);
     await writeFile(path.join(runDir, "raw.md"), contentFile(payload, content, links), generatedFiles);
     await writeFile(path.join(runDir, "source-card.md"), sourceCard(payload, runDirName, links, grounding), generatedFiles);
     const wikiEntryResult = renderWikiEntry(payload, links);
     await writeFile(path.join(runDir, "wiki-entry.md"), wikiEntryResult.markdown, generatedFiles);
-    await writeFile(path.join(runDir, "creative-assets.md"), creativeAssets(payload, links), generatedFiles);
-    await writeFile(path.join(runDir, "topics.md"), topics(payload, links), generatedFiles);
-    await writeFile(path.join(runDir, "draft-outline.md"), outline(payload, links), generatedFiles);
+    if (optionalOutputs.assets && links.assets) {
+        await writeFile(path.join(runDir, "creative-assets.md"), creativeAssets(payload, links), generatedFiles);
+    }
+    if (optionalOutputs.topics && links.topics) {
+        await writeFile(path.join(runDir, "topics.md"), topics(payload, links), generatedFiles);
+    }
+    if (optionalOutputs.outline && links.outline) {
+        await writeFile(path.join(runDir, "draft-outline.md"), outline(payload, links), generatedFiles);
+    }
     await writeFile(longTermTargets.raw, contentFile(payload, content, links), generatedFiles);
     await writeFile(longTermTargets.sourceCard, sourceCard(payload, runDirName, links, grounding), generatedFiles);
     await writeFile(longTermTargets.wikiEntry, wikiEntryResult.markdown, generatedFiles);
-    await writeFile(longTermTargets.claims, claims(payload, links, grounding), generatedFiles);
-    await writeFile(longTermTargets.assets, creativeAssets(payload, links), generatedFiles);
-    await writeFile(longTermTargets.topics, topics(payload, links), generatedFiles);
-    await writeFile(longTermTargets.outline, outline(payload, links), generatedFiles);
+    if (optionalOutputs.claims && longTermTargets.claims) {
+        await writeFile(longTermTargets.claims, claims(payload, links, grounding), generatedFiles);
+    }
+    if (optionalOutputs.assets && longTermTargets.assets) {
+        await writeFile(longTermTargets.assets, creativeAssets(payload, links), generatedFiles);
+    }
+    if (optionalOutputs.topics && longTermTargets.topics) {
+        await writeFile(longTermTargets.topics, topics(payload, links), generatedFiles);
+    }
+    if (optionalOutputs.outline && longTermTargets.outline) {
+        await writeFile(longTermTargets.outline, outline(payload, links), generatedFiles);
+    }
     const warnings = [...payload.warnings, ...groundingWarnings(grounding), ...collisionWarnings];
     await writeSummary(root, runDir, payload, generatedFiles, warnings, links, grounding);
     return { runId, runDir, generatedFiles, warnings, agentReport: buildAgentReport(root, runDir, payload, generatedFiles) };
@@ -69,7 +84,7 @@ export async function ingestFile(rootPath, filePath) {
         },
         request: {
             mode: "ingest",
-            outputs: ["source_card", "creative_assets", "topics", "draft_outline", "processing_summary"],
+            outputs: ["source_card", "wiki_entry", "processing_summary"],
             language: "zh-CN"
         }
     });
@@ -77,19 +92,29 @@ export async function ingestFile(rootPath, filePath) {
 export function deriveFileTitle(filePath) {
     return path.basename(filePath, path.extname(filePath));
 }
-async function chooseLongTermTargets(root, slug, runId, warnings) {
+async function chooseLongTermTargets(root, slug, runId, warnings, plan) {
     return {
         raw: await chooseLongTermTarget(root, "02-raw/articles", `${slug}.md`, runId, warnings),
         sourceCard: await chooseLongTermTarget(root, "03-sources/article-cards", `${slug}.md`, runId, warnings),
         wikiEntry: await chooseLongTermTarget(root, "05-wiki/source-knowledge", `${slug}.md`, runId, warnings),
-        claims: await chooseLongTermTarget(root, "04-claims/_suggestions", `${slug}-claims.md`, runId, warnings),
-        assets: await chooseLongTermTarget(root, "06-assets/_suggestions", `${slug}-assets.md`, runId, warnings),
-        topics: await chooseLongTermTarget(root, "07-topics/ready", `${slug}-topics.md`, runId, warnings),
-        outline: await chooseLongTermTarget(root, "08-outputs/outlines", `${slug}-outline.md`, runId, warnings)
+        claims: plan.claims ? await chooseLongTermTarget(root, "04-claims/_suggestions", `${slug}-claims.md`, runId, warnings) : undefined,
+        assets: plan.assets ? await chooseLongTermTarget(root, "06-assets/_suggestions", `${slug}-assets.md`, runId, warnings) : undefined,
+        topics: plan.topics ? await chooseLongTermTarget(root, "07-topics/ready", `${slug}-topics.md`, runId, warnings) : undefined,
+        outline: plan.outline ? await chooseLongTermTarget(root, "08-outputs/outlines", `${slug}-outline.md`, runId, warnings) : undefined
+    };
+}
+function optionalOutputPlan(payload) {
+    const outputs = new Set(payload.request.outputs);
+    return {
+        claims: outputs.has("claims") || outputs.has("claim_suggestions") || Boolean(payload.analysis?.claims.length),
+        assets: outputs.has("creative_assets"),
+        topics: outputs.has("topics") || Boolean(payload.analysis?.topic_candidates.length),
+        outline: outputs.has("draft_outline") || Boolean(payload.analysis?.outline || payload.analysis?.suggested_links.length || payload.analysis?.reusable_judgments.length)
     };
 }
 async function chooseLongTermTarget(root, dir, fileName, runId, warnings) {
     const target = safeJoin(root, dir, fileName);
+    await fs.mkdir(path.dirname(target), { recursive: true });
     try {
         await fs.access(target);
     }
@@ -260,10 +285,10 @@ function sourceCard(payload, runId, links, grounding) {
         "",
         `- Wiki 条目：${obsidianLink(links.wikiEntry, "Wiki 条目")}`,
         `- 原文：${obsidianLink(links.raw, "原文")}`,
-        `- Claim 建议：${obsidianLink(links.claims, "Claim 建议")}`,
-        `- 素材建议：${obsidianLink(links.assets, "素材建议")}`,
-        `- 选题：${obsidianLink(links.topics, "选题")}`,
-        `- 大纲：${obsidianLink(links.outline, "大纲")}`,
+        ...(links.claims ? [`- Claim 建议：${obsidianLink(links.claims, "Claim 建议")}`] : []),
+        ...(links.assets ? [`- 素材建议：${obsidianLink(links.assets, "素材建议")}`] : []),
+        ...(links.topics ? [`- 选题：${obsidianLink(links.topics, "选题")}`] : []),
+        ...(links.outline ? [`- 大纲：${obsidianLink(links.outline, "大纲")}`] : []),
         `- 处理记录：${obsidianLink(links.runSummary, "处理记录")}`,
         "",
         "## 摘要",
@@ -380,7 +405,7 @@ function topics(payload, links) {
         "",
         `- Wiki 条目：${obsidianLink(links.wikiEntry, "Wiki 条目")}`,
         `- 资料卡：${obsidianLink(links.sourceCard, "资料卡")}`,
-        `- 大纲：${obsidianLink(links.outline, "大纲")}`,
+        ...(links.outline ? [`- 大纲：${obsidianLink(links.outline, "大纲")}`] : []),
         `- ${payload.source.title ?? "Untitled"}`,
         ""
     ].join("\n");
@@ -530,10 +555,10 @@ function buildArtifactLinks(root, slug, runDirName, createdAt, contentFingerprin
         raw: relativePath(root, longTermTargets.raw),
         sourceCard: relativePath(root, longTermTargets.sourceCard),
         wikiEntry: relativePath(root, longTermTargets.wikiEntry),
-        claims: relativePath(root, longTermTargets.claims),
-        assets: relativePath(root, longTermTargets.assets),
-        topics: relativePath(root, longTermTargets.topics),
-        outline: relativePath(root, longTermTargets.outline),
+        claims: longTermTargets.claims ? relativePath(root, longTermTargets.claims) : undefined,
+        assets: longTermTargets.assets ? relativePath(root, longTermTargets.assets) : undefined,
+        topics: longTermTargets.topics ? relativePath(root, longTermTargets.topics) : undefined,
+        outline: longTermTargets.outline ? relativePath(root, longTermTargets.outline) : undefined,
         runSummary: `09-runs/${runDirName}/processing-summary.md`
     };
 }
@@ -545,10 +570,10 @@ function relationshipFrontmatter(links) {
         `wiki_entry: "${escapeYaml(obsidianLink(links.wikiEntry, "Wiki 条目"))}"`,
         `source_card: "${escapeYaml(obsidianLink(links.sourceCard, "资料卡"))}"`,
         `raw_note: "${escapeYaml(obsidianLink(links.raw, "原文"))}"`,
-        `claims_note: "${escapeYaml(obsidianLink(links.claims, "Claim 建议"))}"`,
-        `assets_note: "${escapeYaml(obsidianLink(links.assets, "素材建议"))}"`,
-        `topics_note: "${escapeYaml(obsidianLink(links.topics, "选题"))}"`,
-        `outline_note: "${escapeYaml(obsidianLink(links.outline, "大纲"))}"`,
+        ...(links.claims ? [`claims_note: "${escapeYaml(obsidianLink(links.claims, "Claim 建议"))}"`] : []),
+        ...(links.assets ? [`assets_note: "${escapeYaml(obsidianLink(links.assets, "素材建议"))}"`] : []),
+        ...(links.topics ? [`topics_note: "${escapeYaml(obsidianLink(links.topics, "选题"))}"`] : []),
+        ...(links.outline ? [`outline_note: "${escapeYaml(obsidianLink(links.outline, "大纲"))}"`] : []),
         `run_summary: "${escapeYaml(obsidianLink(links.runSummary, "处理记录"))}"`
     ];
 }

package/dist/src/lint.js

@@ -2,7 +2,7 @@ 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";
+import { exists, OPTIONAL_DIRS, OPTIONAL_PARENT_DIRS } 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");
@@ -20,6 +20,7 @@ export async function lintWorkspace(rootPath, now = new Date().toISOString()) {
     ];
     const issues = [];
     issues.push(...await systemFileIssues(root));
+    issues.push(...await emptyOptionalDirectoryIssues(root));
     const wikiSourceCards = new Set(wikiEntries.map((note) => frontmatterString(note.frontmatter, "source_card")).filter(Boolean));
     for (const card of sourceCards) {
         if (!wikiSourceCards.has(card.path)) {
@@ -135,6 +136,7 @@ export async function lintWorkspace(rootPath, now = new Date().toISOString()) {
             raw_files: rawFiles.length,
             runs: runs.length
         },
+        safe_fixes: safeFixSummary(issues),
         issues
     };
 }
@@ -144,9 +146,31 @@ export function filterLintReport(report, severity) {
     }
     return {
         ...report,
+        safe_fixes: safeFixSummary(report.issues.filter((issue) => issue.severity === severity), report.safe_fixes.applied),
         issues: report.issues.filter((issue) => issue.severity === severity)
     };
 }
+export async function removeEmptyOptionalDirs(rootPath) {
+    const root = path.resolve(rootPath);
+    const applied = [];
+    for (const dir of [...OPTIONAL_DIRS].sort((left, right) => right.length - left.length)) {
+        if (await removeKnownEmptyDir(root, dir)) {
+            applied.push(safeFixFor(dir));
+        }
+    }
+    for (const dir of [...OPTIONAL_PARENT_DIRS].sort((left, right) => right.length - left.length)) {
+        if (await removeKnownEmptyDir(root, dir)) {
+            applied.push(safeFixFor(dir));
+        }
+    }
+    return applied;
+}
+export function attachAppliedSafeFixes(report, applied) {
+    return {
+        ...report,
+        safe_fixes: safeFixSummary(report.issues, applied)
+    };
+}
 export async function writeLintReport(rootPath, report) {
     const root = path.resolve(rootPath);
     const target = safeJoin(root, "dashboards", "Lint Report.md");
@@ -171,6 +195,8 @@ export function renderLintReport(report) {
         `- Errors: ${counts.error}`,
         `- Warnings: ${counts.warning}`,
         `- Info: ${counts.info}`,
+        `- Safe Fixes Available: ${report.safe_fixes.available}`,
+        `- Only Safe Fixes: ${report.safe_fixes.only_safe_fixes ? "yes" : "no"}`,
         `- Top Issue: ${topIssue ? formatIssueLine(topIssue) : "none"}`,
         "",
         "## Suggested Handling Order",
@@ -190,6 +216,7 @@ export function renderLintSummary(report, reportPath) {
     const topIssue = report.issues[0];
     return [
         `lint_summary: errors=${counts.error} warnings=${counts.warning} info=${counts.info}`,
+        `safe_fixes: available=${report.safe_fixes.available} applied=${report.safe_fixes.applied.length} only_safe_fixes=${report.safe_fixes.only_safe_fixes ? "yes" : "no"}`,
         `top_issue: ${topIssue ? formatIssueLine(topIssue) : "none"}`,
         ...(reportPath ? [`report: ${reportPath}`] : [])
     ].join("\n");
@@ -211,6 +238,62 @@ async function systemFileIssues(root) {
     }
     return issues;
 }
+async function emptyOptionalDirectoryIssues(root) {
+    const issues = [];
+    for (const dir of [...OPTIONAL_DIRS, ...OPTIONAL_PARENT_DIRS]) {
+        if (!(await isExistingEmptyDirectory(path.join(root, dir)))) {
+            continue;
+        }
+        issues.push({
+            severity: "info",
+            path: dir,
+            category: "empty_optional_directory",
+            action: "remove_empty_optional_dir",
+            message: `Optional directory is empty and can be safely removed: ${dir}`,
+            suggestion: "Run aiwiki lint --fix-empty-dirs --json to remove known empty optional directories.",
+            safe_fix: safeFixFor(dir)
+        });
+    }
+    return issues;
+}
+async function removeKnownEmptyDir(root, dir) {
+    const target = path.join(root, dir);
+    if (!(await isExistingEmptyDirectory(target))) {
+        return false;
+    }
+    await fs.rmdir(target);
+    return true;
+}
+async function isExistingEmptyDirectory(target) {
+    try {
+        const stats = await fs.stat(target);
+        if (!stats.isDirectory()) {
+            return false;
+        }
+        return (await fs.readdir(target)).length === 0;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function safeFixFor(dir) {
+    return {
+        action: "remove_empty_optional_dir",
+        path: dir,
+        command: "aiwiki lint --fix-empty-dirs --json"
+    };
+}
+function safeFixSummary(issues, applied = []) {
+    const available = issues.filter((issue) => issue.safe_fix).length;
+    return {
+        available,
+        applied,
+        only_safe_fixes: issues.length > 0 && issues.every((issue) => Boolean(issue.safe_fix))
+    };
+}
 async function readNotes(root, dir) {
     const absolute = path.join(root, dir);
     if (!(await exists(absolute))) {

package/dist/src/payload.js

@@ -40,11 +40,8 @@ export function normalizePayload(raw, runStartedAt) {
     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", "wiki_entry", "creative_assets", "topics", "draft_outline", "processing_summary"];
-    if (fetchStatus !== "failed" && requestedOutputs.length && hasCustomOutputRequest(requestedOutputs)) {
-        warnings.push("AIWiki 会为每条输入生成完整资料产物，request.outputs 已按全量输出处理。");
-    }
+        : undefined;
+    const outputs = normalizeOutputs(requestedOutputs, fetchStatus, warnings);
     if (typeof raw.target_kb === "string" && raw.target_kb.trim()) {
         warnings.push(`target_kb=${raw.target_kb} 已被当前知识库流程忽略。`);
     }
@@ -313,9 +310,27 @@ function hasAnalysisContent(analysis) {
         analysis.suggested_links.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);
+function normalizeOutputs(outputs, fetchStatus, warnings) {
+    if (fetchStatus === "failed") {
+        return ["processing_summary"];
+    }
+    const core = ["source_card", "wiki_entry", "processing_summary"];
+    const allowed = new Set([
+        ...core,
+        "claims",
+        "claim_suggestions",
+        "creative_assets",
+        "topics",
+        "draft_outline"
+    ]);
+    const requested = outputs ?? core;
+    const normalized = new Set(core);
+    for (const output of requested) {
+        if (!allowed.has(output)) {
+            warnings.push(`request.outputs ignored unknown output: ${output}`);
+            continue;
+        }
+        normalized.add(output);
+    }
+    return [...normalized];
 }

package/dist/src/wiki-entry.js

@@ -32,9 +32,9 @@ function wikiFrontmatter(payload, links, title, mode, quality, grounding) {
         `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)}"`,
+        ...(links.claims ? [`claims_file: "${escapeYaml(links.claims)}"`] : []),
+        ...(links.topics ? [`topics_file: "${escapeYaml(links.topics)}"`] : []),
+        ...(links.outline ? [`outline_file: "${escapeYaml(links.outline)}"`] : []),
         `run_summary: "${escapeYaml(links.runSummary)}"`,
         `run_id: "${escapeYaml(links.runId)}"`,
         `content_fingerprint: "${escapeYaml(links.contentFingerprint)}"`,