czon 0.8.8 → 0.8.10

package/dist/build/pipeline.js

@@ -71,16 +71,15 @@ async function buildPipeline(options) {
     await (0, opencode_1.installAgentsToGlobal)();
     // 清理输出目录
     await fs.rm(paths_1.CZON_DIST_DIR, { recursive: true, force: true });
+    // 扫描源文件
+    await (0, scanSourceFiles_1.scanSourceFiles)();
     // 确保 .czon/.gitignore 文件
     await (0, writeFile_1.writeFile)(path.join(paths_1.CZON_DIR, '.gitignore'), [
         'dist',
         'tmp',
         // 忽略所有非 md 文件: 先忽略所有文件，再排除 Markdown 文件不忽略
-        'src/**/*.*',
-        '!src/**/*.md',
+        ...Array.from(new Set(metadata_1.MetaData.files.filter(f => !f.path.endsWith('.md')).map(f => path.extname(f.path)))).map(ext => `src/**/*${ext}`),
     ].join('\n'));
-    // 扫描源文件
-    await (0, scanSourceFiles_1.scanSourceFiles)();
     // 链接资源文件 (非翻译文件)
     for (const file of metadata_1.MetaData.files) {
         if (file.path.endsWith('.md'))

package/dist/commands/ls-files.js

@@ -4,9 +4,15 @@ exports.LsFilesCommand = void 0;
 const clipanion_1 = require("clipanion");
 const findEntries_1 = require("../findEntries");
 class LsFilesCommand extends clipanion_1.Command {
+    constructor() {
+        super(...arguments);
+        this.aigc = clipanion_1.Option.Boolean('--aigc', false, {
+            description: 'Include files under .czon/AIGC directory',
+        });
+    }
     async execute() {
         try {
-            const files = await (0, findEntries_1.findMarkdownEntries)(process.cwd());
+            const files = await (0, findEntries_1.findMarkdownEntries)(process.cwd(), { aigc: this.aigc });
             if (files.length === 0) {
                 this.context.stdout.write('No markdown files found.\n');
             }

package/dist/findEntries.js

@@ -12,9 +12,12 @@ const execAsync = (0, util_1.promisify)(child_process_1.exec);
  * 然后过滤掉.czon目录和只保留.md文件
  *
  * @param dirPath 要扫描的目录路径
+ * @param options 可选参数
+ * @param options.aigc 是否包含 .czon/AIGC 目录下的文件
  * @returns Promise<string[]> 返回Markdown文件的相对路径数组
  */
-const findMarkdownEntries = async (dirPath) => {
+const findMarkdownEntries = async (dirPath, options) => {
+    const aigc = options?.aigc ?? false;
     // 获取git仓库的根目录
     const gitRoot = (await execAsync('git rev-parse --show-toplevel', { cwd: dirPath })).stdout.trim();
     // 使用git命令获取所有文件（包括已跟踪和未跟踪的文件）
@@ -27,7 +30,7 @@ const findMarkdownEntries = async (dirPath) => {
     const files = stdout
         .split('\0') // 按空字符分割文件名
         .filter(line => line.trim() !== '') // 移除空行
-        .filter(file => !file.startsWith('.')) // 过滤掉隐藏目录下的文件
+        .filter(file => !file.startsWith('.') || (aigc && file.startsWith('.czon/AIGC/'))) // 过滤掉隐藏目录下的文件（aigc 模式下保留 .czon/AIGC/）
         .filter(file => file.endsWith('.md')); // 只保留.md文件
     // 排除文件系统中不存在的文件
     const existingFiles = [];

package/dist/process/scanSourceFiles.js

@@ -25,7 +25,7 @@ async function scanSourceFiles() {
     console.log(`🔍 Scanning source directory...`);
     const queue = [];
     const isVisited = new Set();
-    const markdownFiles = await (0, findEntries_1.findMarkdownEntries)(paths_1.INPUT_DIR);
+    const markdownFiles = await (0, findEntries_1.findMarkdownEntries)(paths_1.INPUT_DIR, { aigc: true });
     for (const filePath of markdownFiles) {
         queue.push(filePath);
     }

package/dist/process/summary.js

@@ -2,21 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processSummary = void 0;
 const promises_1 = require("fs/promises");
-const fs_1 = require("fs");
 const path_1 = require("path");
+const paths_1 = require("../paths");
 const opencode_1 = require("../services/opencode");
 // Prompt 模板目录路径（在项目根目录的 prompts/ 文件夹中）
 const PROMPTS_DIR = (0, path_1.join)(__dirname, '../../prompts');
+// 输出目录：.czon/AIGC/SUMMARY/
+const SUMMARY_DIR = (0, path_1.join)(paths_1.CZON_DIR, 'AIGC', 'SUMMARY');
+// 最大重试次数
+const MAX_RETRIES = 3;
 // 风格配置
 const SUMMARY_STYLES = [
-    { skill: 'summary-objective', output: '1-objective.md', name: '客观中立' },
-    { skill: 'summary-critical', output: '2-critical.md', name: '客观批判' },
-    { skill: 'summary-positive', output: '3-positive.md', name: '赞扬鼓励' },
-    { skill: 'summary-popular', output: '4-popular.md', name: '科普介绍' },
-    { skill: 'summary-artistic', output: '5-artistic.md', name: '文艺感性' },
-    { skill: 'summary-philosophical', output: '6-philosophical.md', name: '哲学思辨' },
-    { skill: 'summary-psychological', output: '7-psychological.md', name: '心理分析' },
-    { skill: 'summary-historical', output: '8-history.md', name: '历史时间跨度' },
+    { skill: 'summary-objective', name: '客观中立' },
+    { skill: 'summary-critical', name: '客观批判' },
+    { skill: 'summary-positive', name: '赞扬鼓励' },
+    { skill: 'summary-popular', name: '科普介绍' },
+    { skill: 'summary-artistic', name: '文艺感性' },
+    { skill: 'summary-philosophical', name: '哲学思辨' },
+    { skill: 'summary-psychological', name: '心理分析' },
+    { skill: 'summary-historical', name: '历史时间跨度' },
 ];
 /**
  * 读取 Prompt 模板文件内容
@@ -26,16 +30,24 @@ const loadPromptTemplate = async (templateName) => {
     return (0, promises_1.readFile)(templatePath, 'utf-8');
 };
 /**
- * 验证文件是否存在
+ * 获取文件的 mtime（毫秒），文件不存在则返回 null
  */
-const verifyFileExists = (filePath) => {
-    return (0, fs_1.existsSync)(filePath);
+const getFileMtimeMs = async (filePath) => {
+    try {
+        const s = await (0, promises_1.stat)(filePath);
+        return s.mtimeMs;
+    }
+    catch {
+        return null;
+    }
 };
 /**
- * 生成单个风格的报告
+ * 生成单个风格的报告（带重试循环）
  */
 const generateStyleReport = async (model, baseContent, styleConfig, cwd) => {
     try {
+        const relativeOutput = `.czon/AIGC/SUMMARY/${styleConfig.skill}.md`;
+        const outputPath = (0, path_1.join)(paths_1.INPUT_DIR, relativeOutput);
         const styleContent = await loadPromptTemplate(styleConfig.skill);
         const prompt = `
 ${baseContent}
@@ -50,23 +62,45 @@ ${styleContent}
 
 请严格按照上述指南，生成「${styleConfig.name}」风格的分析报告。
 
-输出文件：SUMMARY/${styleConfig.output}
+输出文件：${relativeOutput}
 
 注意：
 1. 必须生成完整的报告文件
-2. 文件必须保存到 SUMMARY/${styleConfig.output}
+2. 文件必须保存到 ${relativeOutput}
 3. 确保所有链接使用 ../ 开头的相对路径
 `.trim();
-        await (0, opencode_1.runOpenCode)(prompt, { model, cwd });
-        // 验证文件是否生成
-        const outputPath = (0, path_1.join)(cwd, 'SUMMARY', styleConfig.output);
-        if (!verifyFileExists(outputPath)) {
-            return {
-                success: false,
-                error: `文件未生成: ${outputPath}`,
-            };
+        // 记录发送前的 mtime
+        const mtimeBefore = await getFileMtimeMs(outputPath);
+        // 发送初始 prompt，获取句柄
+        const handle = await (0, opencode_1.runOpenCode)(prompt, { model, cwd });
+        // 验证 + 重试循环
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            const mtimeAfter = await getFileMtimeMs(outputPath);
+            const fileExists = mtimeAfter !== null;
+            const fileModified = mtimeBefore !== mtimeAfter;
+            if (fileExists && fileModified) {
+                return { success: true };
+            }
+            // 构造错误反馈
+            let errorMsg;
+            if (!fileExists) {
+                errorMsg = `错误：文件 ${relativeOutput} 未生成。请立即创建并写入完整的报告内容到 ${relativeOutput}。`;
+            }
+            else {
+                errorMsg = `错误：文件 ${relativeOutput} 未被修改。请重新生成完整内容并覆盖写入 ${relativeOutput}。`;
+            }
+            console.warn(`  ⚠️ 重试 ${attempt}/${MAX_RETRIES}: ${errorMsg}`);
+            await handle.prompt(errorMsg);
+        }
+        // 最终检查
+        const mtimeFinal = await getFileMtimeMs(outputPath);
+        if (mtimeFinal !== null && mtimeBefore !== mtimeFinal) {
+            return { success: true };
         }
-        return { success: true };
+        return {
+            success: false,
+            error: `${MAX_RETRIES} 次重试后仍未成功生成文件: ${relativeOutput}`,
+        };
     }
     catch (error) {
         return {
@@ -83,10 +117,6 @@ const processSummary = async (model) => {
     // 加载基础规则
     console.info('📖 加载基础规则...');
     const baseContent = await loadPromptTemplate('summary-base');
-    // Phase 0: 清空 SUMMARY 目录
-    console.info('🗑️  清空 SUMMARY 目录...');
-    await (0, promises_1.rm)((0, path_1.join)(cwd, 'SUMMARY'), { recursive: true, force: true });
-    await (0, promises_1.mkdir)((0, path_1.join)(cwd, 'SUMMARY'), { recursive: true });
     // Phase 1: 串行生成 8 种风格报告
     console.info(`\n📊 开始生成 ${SUMMARY_STYLES.length} 种风格的分析报告...\n`);
     const results = [];
@@ -96,7 +126,6 @@ const processSummary = async (model) => {
         const result = await generateStyleReport(model, baseContent, style, cwd);
         results.push({
             name: style.name,
-            output: style.output,
             ...result,
         });
         if (result.success) {
@@ -114,7 +143,7 @@ const processSummary = async (model) => {
     if (failedResults.length > 0) {
         console.info('❌ 失败的报告:');
         for (const failed of failedResults) {
-            console.info(`   - ${failed.name} (${failed.output}): ${failed.error}`);
+            console.info(`   - ${failed.name}: ${failed.error}`);
         }
         console.info('');
     }
@@ -122,10 +151,10 @@ const processSummary = async (model) => {
     console.info('📁 验证文件存在性:');
     let allFilesExist = true;
     for (const style of SUMMARY_STYLES) {
-        const filePath = (0, path_1.join)(cwd, 'SUMMARY', style.output);
-        const exists = verifyFileExists(filePath);
+        const filePath = (0, path_1.join)(SUMMARY_DIR, style.skill + '.md');
+        const exists = (await getFileMtimeMs(filePath)) !== null;
         const status = exists ? '✅' : '❌';
-        console.info(`   ${status} SUMMARY/${style.output}`);
+        console.info(`   ${status} .czon/AIGC/SUMMARY/${style.skill}.md`);
         if (!exists) {
             allFilesExist = false;
         }

package/dist/services/opencode.js

@@ -5,6 +5,18 @@ const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const paths_1 = require("../paths");
 const writeFile_1 = require("../utils/writeFile");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Retry delays for transient network errors (exponential back-off). */
+const RETRY_DELAYS_MS = [1000, 2000, 4000];
+/** Interval between status polls while waiting for a session to become idle. */
+const POLL_INTERVAL_MS = 2000;
+/** Maximum time to wait for a session to become idle (10 minutes). */
+const POLL_MAX_DURATION_MS = 600000;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
 function parseModelString(model) {
     const parts = model.split('/');
     if (parts.length === 2) {
@@ -13,111 +25,143 @@ function parseModelString(model) {
     // Default provider if no slash
     return { providerID: 'opencode', modelID: model };
 }
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Retry `fn` on transient network errors (TypeError / "fetch failed").
+ * Non-network errors are re-thrown immediately.
+ */
+async function withRetry(fn) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (attempt >= RETRY_DELAYS_MS.length)
+                throw err;
+            const isNetworkError = err instanceof TypeError || (err instanceof Error && err.message.includes('fetch failed'));
+            if (!isNetworkError)
+                throw err;
+            const delay = RETRY_DELAYS_MS[attempt];
+            console.warn(`⚠️ Network error, retrying in ${delay}ms... (${attempt + 1}/${RETRY_DELAYS_MS.length})`);
+            await sleep(delay);
+        }
+    }
+}
+/**
+ * Poll `session.status()` until the given session becomes idle.
+ * Individual poll failures are silently retried (the server is still running,
+ * just a transient network hiccup).
+ */
+async function pollUntilIdle(client, sessionId, cwd, signal) {
+    const deadline = Date.now() + POLL_MAX_DURATION_MS;
+    while (Date.now() < deadline) {
+        if (signal?.aborted) {
+            throw new Error('OpenCode execution was aborted');
+        }
+        await sleep(POLL_INTERVAL_MS);
+        try {
+            const statusResp = await client.session.status({
+                query: { directory: cwd },
+            });
+            const statuses = statusResp.data ?? {};
+            const sessionStatus = statuses[sessionId];
+            if (!sessionStatus || sessionStatus.type === 'idle') {
+                return; // done
+            }
+            // busy / retry → keep polling
+        }
+        catch {
+            // Network error → ignore, keep polling
+            console.warn('⚠️ Status poll failed, will retry...');
+        }
+    }
+    throw new Error(`OpenCode session timed out after ${POLL_MAX_DURATION_MS / 1000}s`);
+}
 /**
  * Run OpenCode to generate AI response for a given prompt.
  *
  * This function uses the OpenCode SDK to connect to a running OpenCode server.
  * Assumes an OpenCode server is already running externally.
  *
+ * Creates a new session, sends the initial prompt, and returns a handle that
+ * can be used to continue the conversation by calling `handle.prompt()`.
+ *
+ * Internally uses `promptAsync()` + status polling instead of the blocking
+ * `prompt()` call, so that long-running AI tasks survive transient network
+ * interruptions.
+ *
  * @param prompt - The prompt to send to OpenCode
  * @param options - Optional configuration
- * @returns Promise that resolves when the operation completes
- *
- * @important
- * The AI response is handled internally by OpenCode. This function does not
- * return the response content. Any output files or results are managed by
- * the OpenCode agent or session directly.
+ * @returns A session handle for continued interaction
  */
-const runOpenCode = (prompt, options) => {
+const runOpenCode = async (prompt, options) => {
     const model = options?.model ?? 'opencode/gpt-5-nano';
     const signal = options?.signal;
     const cwd = options?.cwd || process.cwd();
     const agent = options?.agent;
-    console.info(`🛠️  Running OpenCode with model: ${model}, agent: ${agent || 'none'}`);
-    return new Promise(async (resolve, reject) => {
-        const agentInfo = agent ? ` with agent ${agent}` : '';
-        console.info(`🚀 Running OpenCode with model ${model}${agentInfo}`);
-        let cancelled = false;
-        const cleanup = () => {
-            if (signal) {
-                signal.removeEventListener('abort', onAbort);
-            }
-        };
-        const onAbort = () => {
-            cancelled = true;
-            cleanup();
-            reject(new Error('OpenCode execution was aborted'));
-        };
-        if (signal) {
-            signal.addEventListener('abort', onAbort);
-            if (signal.aborted) {
-                onAbort();
-                return;
-            }
-        }
-        try {
-            const { createOpencodeClient } = await import('@opencode-ai/sdk');
-            const baseUrl = 'http://localhost:4096';
-            const client = createOpencodeClient({
-                baseUrl: baseUrl,
-                directory: cwd,
-            });
-            const modelObj = parseModelString(model);
-            const session = await client.session.create();
-            if (!session.data?.id)
-                throw new Error('Failed to create OpenCode session', { cause: session.error });
-            options?.signal?.addEventListener('abort', () => {
-                console.info(`🛑 Aborting OpenCode session ${session.data.id}...`);
-                client.session.abort({
-                    path: {
-                        id: session.data.id,
+    const agentInfo = agent ? ` with agent ${agent}` : '';
+    console.info(`🚀 Running OpenCode with model ${model}${agentInfo}`);
+    const { createOpencodeClient } = await import('@opencode-ai/sdk');
+    const baseUrl = 'http://localhost:4096';
+    const client = createOpencodeClient({
+        baseUrl: baseUrl,
+        directory: cwd,
+    });
+    const modelObj = parseModelString(model);
+    const session = await client.session.create();
+    if (!session.data?.id)
+        throw new Error('Failed to create OpenCode session', { cause: session.error });
+    const sessionId = session.data.id;
+    const directoryBase64 = Buffer.from(session.data.directory).toString('base64');
+    const url = `${baseUrl}/${directoryBase64}/session/${sessionId}`;
+    console.info('OpenCode Session Created', url);
+    const handle = {
+        sessionId,
+        url,
+        async prompt(text, promptOptions) {
+            const promptSignal = promptOptions?.signal;
+            // Step 1: Send the message asynchronously (short request, returns 204)
+            await withRetry(async () => {
+                const resp = await client.session.promptAsync({
+                    path: { id: sessionId },
+                    body: {
+                        model: modelObj,
+                        agent,
+                        parts: [{ type: 'text', text }],
                     },
+                    query: { directory: cwd },
+                    signal: promptSignal,
                 });
+                if (resp.error) {
+                    throw new Error(`OpenCode API error: ${JSON.stringify(resp.error)}`);
+                }
             });
-            const directoryBase64 = Buffer.from(session.data.directory).toString('base64');
-            const url = `${baseUrl}/${directoryBase64}/session/${session.data.id}`;
-            console.info('OpenCode Session Created', url);
-            const response = await client.session.prompt({
-                path: {
-                    id: session.data.id,
-                },
-                body: {
-                    model: modelObj,
-                    agent,
-                    parts: [
-                        {
-                            type: 'text',
-                            text: prompt,
-                        },
-                    ],
-                },
-                query: {
-                    directory: cwd,
-                },
-                signal,
-            });
-            if (cancelled) {
-                throw new Error('Cancelled');
-            }
-            if (response.error) {
-                throw new Error(`OpenCode API error: ${JSON.stringify(response.error)}`);
-            }
-            // await client.session.delete({
-            //   path: {
-            //     id: session.data.id,
-            //   },
-            // });
-            cleanup();
-            resolve();
-        }
-        catch (err) {
-            if (cancelled) {
-                return;
+            // Step 2: Poll until the session becomes idle
+            await pollUntilIdle(client, sessionId, cwd, promptSignal);
+            // Step 3: Fetch the latest assistant message
+            const msgs = await withRetry(() => client.session.messages({
+                path: { id: sessionId },
+                query: { directory: cwd },
+            }));
+            const allMessages = msgs.data ?? [];
+            const lastAssistant = [...allMessages].reverse().find(m => m.info.role === 'assistant');
+            if (!lastAssistant) {
+                throw new Error('No assistant response found after prompt');
             }
-            cleanup();
-            reject(new Error(`OpenCode SDK error: ${err instanceof Error ? err.message : String(err)}. Make sure an OpenCode server is running.`));
-        }
-    });
+            return lastAssistant;
+        },
+        async abort() {
+            await client.session.abort({ path: { id: sessionId } });
+        },
+        async delete() {
+            await client.session.delete({ path: { id: sessionId } });
+        },
+    };
+    // Send the initial prompt
+    await handle.prompt(prompt, { signal });
+    return handle;
 };
 exports.runOpenCode = runOpenCode;
 const installAgentsToGlobal = async () => {

package/dist/utils/convertMarkdownToHtml.js

@@ -48,7 +48,8 @@ const convertMarkdownToHtml = (article, path, lang, mdContent) => {
         const file = metadata_1.MetaData.files.find(f => f.path === resolvedPath);
         if (!file) {
             console.warn(`⚠️ Link target not found for path ${resolvedPath} in file ${path}`);
-            return originalLinkRenderer.call(this, link);
+            // 链接目标不存在，使用斜体表示损坏的链接，不渲染为 <a> 标签
+            return `<em title="Link target not found: ${escapeHtml(link.href)}">${link.text}</em>`;
         }
         if (link.href.endsWith('.md')) {
             if (!file.metadata?.slug) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "czon",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "description": "CZON - AI enhanced Markdown content engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prompts/summary-artistic.md

@@ -118,10 +118,6 @@
 - 使用节奏：长短句交替，创造韵律感
 - 引用原文：选择有感染力的句子
 
-## 输出文件
-
-`SUMMARY/5-artistic.md`
-
 ## 质量检查清单
 
 - [ ] 语言富有画面感

package/prompts/summary-base.md

@@ -41,10 +41,58 @@
 
 **如果发现遗漏**：返回阶段 2 处理遗漏的文件。
 
-### 阶段 5：生成报告
+### 阶段 5：生成报告（分段写入）
 
 只有在完成以上所有阶段后，才能开始生成报告。
 
+由于报告内容可能很长，**必须分段写入**，禁止一次性写入整个报告。
+
+#### 步骤 1：写入骨架文件
+
+首先，使用 Write 工具创建报告文件，写入以下内容：
+
+- 头部格式（标题、AI 分析时间、文件数量、注释、分隔线）
+- 所有章节的标题（仅标题，不含正文）
+- 每个章节标题下方放置占位标记：`<!-- SECTION: [章节名] -->`
+
+**示例骨架**：
+
+```markdown
+# 报告标题
+
+**AI 分析时间**：2025年01月01日
+**基于 42 个 Markdown 文件生成**
+**注**：本报告由 AI 生成，内容仅供参考。
+
+---
+
+## 概述
+
+<!-- SECTION: 概述 -->
+
+## 第二章标题
+
+<!-- SECTION: 第二章标题 -->
+
+...
+```
+
+#### 步骤 2：逐章节填充内容
+
+按章节顺序，使用 Edit 工具逐一替换占位标记为实际内容：
+
+1. 每次只填充**一个章节**的内容
+2. 将 `<!-- SECTION: [章节名] -->` 替换为该章节的完整正文
+3. 单次写入内容控制在 **2000 字以内**。如果某个章节超过 2000 字，将其拆分为多次写入（先写入前半部分并在末尾保留一个临时占位标记，再继续写入后半部分）
+
+#### 步骤 3：完整性检查
+
+所有章节填充完毕后：
+
+1. 读取完整文件，确认无遗漏的 `<!-- SECTION:` 占位标记
+2. 确认所有链接格式正确（相对路径以 `../` 开头，链接文本为文章标题）
+3. 确认头部的文件数量 N 正确
+
 ### 禁止行为
 
 - ❌ 不得在阅读完所有文件前开始生成报告
@@ -103,8 +151,3 @@
 
 - 考虑时间跨度，给予最近的文章更高的权重
 - 但不要忽略较早的重要内容
-
-### 5. 输出位置
-
-- 所有报告生成到 `SUMMARY/` 目录中
-- 文件名按指定格式命名

package/prompts/summary-critical.md

@@ -136,10 +136,6 @@
 2. 建议 2：具体可操作的改进方案
 ```
 
-## 输出文件
-
-`SUMMARY/2-critical.md`
-
 ## 质量检查清单
 
 - [ ] 每个批评点都有事实依据

package/prompts/summary-historical.md

@@ -154,10 +154,6 @@
 - 关键洞察
 - 历史意义
 
-## 输出文件
-
-`SUMMARY/8-history.md`
-
 ## 质量检查清单
 
 - [ ] 时间线准确

package/prompts/summary-objective.md

@@ -129,10 +129,6 @@
 - **数学表达**：如有公式，列出
 ```
 
-## 输出文件
-
-`SUMMARY/1-objective.md`
-
 ## 质量检查清单
 
 - [ ] 无主观评价词汇

package/prompts/summary-philosophical.md

@@ -132,10 +132,6 @@
 - 批判理论：权力、解放、批判
 - 东方哲学：道、无为、中庸
 
-## 输出文件
-
-`SUMMARY/6-philosophical.md`
-
 ## 质量检查清单
 
 - [ ] 命题清晰明确

package/prompts/summary-popular.md

@@ -117,10 +117,6 @@
 
 推荐阅读顺序，从最易懂的开始
 
-## 输出文件
-
-`SUMMARY/4-popular.md`
-
 ## 质量检查清单
 
 - [ ] 无未解释的专业术语

package/prompts/summary-positive.md

@@ -115,10 +115,6 @@
 - 未来潜力展望
 - 鼓励性结语
 
-## 输出文件
-
-`SUMMARY/3-positive.md`
-
 ## 质量检查清单
 
 - [ ] 所有赞扬都有事实依据

package/prompts/summary-psychological.md

@@ -161,10 +161,6 @@
 - 发展建议
 - 心理健康风险评估
 
-## 输出文件
-
-`SUMMARY/7-psychological.md`
-
 ## 质量检查清单
 
 - [ ] MBTI 四个维度都有分析