czon 0.9.0 → 0.9.2

package/dist/cli.js

@@ -16,6 +16,7 @@ const cli = new clipanion_1.Cli({
 // 注册命令
 cli.register(commands_1.BuildCommand);
 cli.register(commands_1.CheckCommand);
+cli.register(commands_1.GenTodoListCommand);
 cli.register(commands_1.LsFilesCommand);
 cli.register(commands_1.SummaryCommand);
 cli.register(commands_1.ConfigGithubCommand);

package/dist/commands/gen-todo-list.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenTodoListCommand = void 0;
+const clipanion_1 = require("clipanion");
+const todoSummary_1 = require("../process/todoSummary");
+class GenTodoListCommand extends clipanion_1.Command {
+    constructor() {
+        super(...arguments);
+        this.model = clipanion_1.Option.String('--model', 'opencode/big-pickle', {
+            description: 'OpenCode model to use for TODO extraction',
+        });
+    }
+    async execute() {
+        try {
+            await (0, todoSummary_1.processTodoSummary)(this.model);
+            return 0;
+        }
+        catch (error) {
+            this.context.stderr.write(`TODO summary generation failed: ${error}\n`);
+            return 1;
+        }
+    }
+}
+exports.GenTodoListCommand = GenTodoListCommand;
+GenTodoListCommand.paths = [['gen', 'todo-list']];
+GenTodoListCommand.usage = clipanion_1.Command.Usage({
+    description: 'Generate a TODO summary by extracting TODOs from all markdown files',
+    details: `
+      This command uses AI to read all markdown files in the repository,
+      extract TODO items (both explicit and implicit), determine their
+      completion status, and assign priority levels.
+
+      The generated report is saved to .czon/AIGC/TODO/todo-summary.md
+
+      Examples:
+        $ czon gen todo-list
+        $ czon gen todo-list --model opencode/gpt-4o
+    `,
+});
+//# sourceMappingURL=gen-todo-list.js.map

package/dist/commands/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SummaryCommand = exports.LsFilesCommand = exports.ConfigGithubCommand = exports.CheckCommand = exports.BuildCommand = void 0;
+exports.SummaryCommand = exports.LsFilesCommand = exports.GenTodoListCommand = exports.ConfigGithubCommand = exports.CheckCommand = exports.BuildCommand = void 0;
 var build_1 = require("./build");
 Object.defineProperty(exports, "BuildCommand", { enumerable: true, get: function () { return build_1.BuildCommand; } });
 var check_1 = require("./check");
 Object.defineProperty(exports, "CheckCommand", { enumerable: true, get: function () { return check_1.CheckCommand; } });
 var config_github_1 = require("./config-github");
 Object.defineProperty(exports, "ConfigGithubCommand", { enumerable: true, get: function () { return config_github_1.ConfigGithubCommand; } });
+var gen_todo_list_1 = require("./gen-todo-list");
+Object.defineProperty(exports, "GenTodoListCommand", { enumerable: true, get: function () { return gen_todo_list_1.GenTodoListCommand; } });
 var ls_files_1 = require("./ls-files");
 Object.defineProperty(exports, "LsFilesCommand", { enumerable: true, get: function () { return ls_files_1.LsFilesCommand; } });
 var summary_1 = require("./summary");

package/dist/commands/ls-files.js

@@ -9,10 +9,13 @@ class LsFilesCommand extends clipanion_1.Command {
         this.aigc = clipanion_1.Option.Boolean('--aigc', false, {
             description: 'Include files under .czon/AIGC directory',
         });
+        this.allTypes = clipanion_1.Option.Boolean('--all-types', false, {
+            description: 'List all file types, not just Markdown files',
+        });
     }
     async execute() {
         try {
-            const files = await (0, findEntries_1.findMarkdownEntries)(process.cwd(), { aigc: this.aigc });
+            const files = await (0, findEntries_1.findEntries)(process.cwd(), { aigc: this.aigc, allTypes: this.allTypes });
             if (files.length === 0) {
                 this.context.stdout.write('No markdown files found.\n');
             }
@@ -35,10 +38,12 @@ LsFilesCommand.usage = clipanion_1.Command.Usage({
     description: 'List all markdown files in the current directory',
     details: `
       This command lists all markdown files in the current directory using git.
-      It uses the same logic as the internal findMarkdownEntries function.
+      It uses the same logic as the internal findEntries function.
+      Use --all-types to list all file types, not just Markdown.
 
       Examples:
         $ czon ls-files
+        $ czon ls-files --all-types
     `,
 });
 //# sourceMappingURL=ls-files.js.map

package/dist/findEntries.js

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMarkdownEntries = void 0;
+exports.findEntries = void 0;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const util_1 = require("util");
 const isExists_1 = require("./utils/isExists");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
- * 使用git命令查找所有Markdown文件
+ * 使用git命令查找项目中的文件
  * 使用git ls-files --others --cached --exclude-standard获取所有文件
- * 然后过滤掉.czon目录和只保留.md文件
+ * 然后过滤掉.czon目录，默认只保留.md文件
  *
  * @param dirPath 要扫描的目录路径
  * @param options 可选参数
  * @param options.aigc 是否包含 .czon/AIGC 目录下的文件
- * @returns Promise<string[]> 返回Markdown文件的相对路径数组
+ * @param options.allTypes 是否返回所有类型的文件（默认 false，仅返回 .md 文件）
+ * @returns Promise<string[]> 返回文件的相对路径数组
  */
-const findMarkdownEntries = async (dirPath, options) => {
+const findEntries = async (dirPath, options) => {
     const aigc = options?.aigc ?? false;
+    const allTypes = options?.allTypes ?? false;
     // 获取git仓库的根目录
     const gitRoot = (await execAsync('git rev-parse --show-toplevel', { cwd: dirPath })).stdout.trim();
     // 使用git命令获取所有文件（包括已跟踪和未跟踪的文件）
@@ -31,7 +33,7 @@ const findMarkdownEntries = async (dirPath, options) => {
         .split('\0') // 按空字符分割文件名
         .filter(line => line.trim() !== '') // 移除空行
         .filter(file => !file.startsWith('.') || (aigc && file.startsWith('.czon/AIGC/'))) // 过滤掉隐藏目录下的文件（aigc 模式下保留 .czon/AIGC/）
-        .filter(file => file.endsWith('.md')); // 只保留.md文件
+        .filter(file => allTypes || file.endsWith('.md')); // allTypes 时返回所有文件，否则只保留 .md 文件
     // 排除文件系统中不存在的文件
     const existingFiles = [];
     for (const file of files) {
@@ -41,5 +43,5 @@ const findMarkdownEntries = async (dirPath, options) => {
     }
     return existingFiles;
 };
-exports.findMarkdownEntries = findMarkdownEntries;
+exports.findEntries = findEntries;
 //# sourceMappingURL=findEntries.js.map

package/dist/process/checkLinks.js

@@ -103,11 +103,22 @@ function extractLinksWithLineNumbers(content) {
  */
 async function checkLinks() {
     console.log('🔍 正在扫描 Markdown 文件...');
-    const markdownFiles = await (0, findEntries_1.findMarkdownEntries)(paths_1.INPUT_DIR, { aigc: true });
+    const markdownFiles = await (0, findEntries_1.findEntries)(paths_1.INPUT_DIR, { aigc: true });
+    const allFiles = await (0, findEntries_1.findEntries)(paths_1.INPUT_DIR, { allTypes: true });
     const issues = [];
     // 构建已知文件集合，用于死链接检测
     const knownFiles = new Set(markdownFiles);
-    console.log(`📄 发现 ${markdownFiles.length} 个 Markdown 文件\n`);
+    // 构建全部文件集合，用于建议生成
+    const allFilesSet = new Set(allFiles);
+    // 构建 basename -> 相对路径列表 的索引，用于模糊匹配
+    const basenameIndex = new Map();
+    for (const file of allFiles) {
+        const base = path_1.default.basename(file);
+        const list = basenameIndex.get(base) ?? [];
+        list.push(file);
+        basenameIndex.set(base, list);
+    }
+    console.log(`📄 发现 ${markdownFiles.length} 个 Markdown 文件，${allFiles.length} 个总文件\n`);
     for (const filePath of markdownFiles) {
         const fullPath = path_1.default.join(paths_1.INPUT_DIR, filePath);
         const content = await (0, promises_1.readFile)(fullPath, 'utf-8');
@@ -125,6 +136,13 @@ async function checkLinks() {
                 continue;
             // 检查 1: 路径格式规范 — 不应使用 / 开头的绝对路径
             if (hrefWithoutHash.startsWith('/')) {
+                // 尝试生成建议：去掉开头的 /，看是否能在已知文件中找到
+                const suggestions = [];
+                const targetRelative = hrefWithoutHash.slice(1); // 去掉开头的 /
+                if (allFilesSet.has(targetRelative)) {
+                    const suggested = path_1.default.relative(path_1.default.dirname(filePath), targetRelative);
+                    suggestions.push(suggested);
+                }
                 issues.push({
                     file: filePath,
                     line: link.line,
@@ -132,6 +150,7 @@ async function checkLinks() {
                     href: link.href,
                     type: 'absolute-path',
                     message: '不应使用 / 开头的绝对路径，请使用相对路径',
+                    suggestions,
                 });
                 // 绝对路径无法正确解析，跳过死链接检测
                 continue;
@@ -147,6 +166,22 @@ async function checkLinks() {
                     href: link.href,
                     type: 'dead-link',
                     message: '链接指向项目目录之外',
+                    suggestions: [],
+                });
+                continue;
+            }
+            // 检查 2: .czon/src 边界隔离 — 外部文件不能引用 .czon/src 内部的文件
+            const sourceIsInternal = filePath.startsWith('.czon/src/');
+            const targetIsInternal = resolvedRelative.startsWith('.czon/src/');
+            if (!sourceIsInternal && targetIsInternal) {
+                issues.push({
+                    file: filePath,
+                    line: link.line,
+                    raw: link.raw,
+                    href: link.href,
+                    type: 'cross-boundary',
+                    message: '不能引用 .czon/src 内部的文件',
+                    suggestions: [],
                 });
                 continue;
             }
@@ -158,6 +193,16 @@ async function checkLinks() {
             // 再检查文件系统
             const resolvedFullPath = path_1.default.join(paths_1.INPUT_DIR, resolvedRelative);
             if (!(await (0, isExists_1.isExists)(resolvedFullPath))) {
+                // 通过 basename 模糊匹配，生成候选建议（最多 3 个）
+                const suggestions = [];
+                const targetBasename = path_1.default.basename(hrefWithoutHash);
+                const candidates = basenameIndex.get(targetBasename) ?? [];
+                for (const candidate of candidates) {
+                    if (suggestions.length >= 3)
+                        break;
+                    const suggested = path_1.default.relative(path_1.default.dirname(filePath), candidate);
+                    suggestions.push(suggested);
+                }
                 issues.push({
                     file: filePath,
                     line: link.line,
@@ -165,6 +210,7 @@ async function checkLinks() {
                     href: link.href,
                     type: 'dead-link',
                     message: '目标文件不存在',
+                    suggestions,
                 });
             }
         }
@@ -189,19 +235,25 @@ function formatCheckResults(issues) {
     for (const [file, fileIssues] of grouped) {
         lines.push(file);
         for (const issue of fileIssues) {
-            const icon = issue.type === 'dead-link' ? '✖' : '⚠';
+            const icon = issue.type === 'dead-link' ? '✖' : issue.type === 'cross-boundary' ? '⊘' : '⚠';
             lines.push(`  line ${issue.line}: ${icon} ${issue.raw}`);
             lines.push(`    ${issue.message}`);
+            for (const suggestion of issue.suggestions) {
+                lines.push(`    建议: ${suggestion}`);
+            }
         }
         lines.push('');
     }
     const deadCount = issues.filter(i => i.type === 'dead-link').length;
     const formatCount = issues.filter(i => i.type === 'absolute-path').length;
+    const boundaryCount = issues.filter(i => i.type === 'cross-boundary').length;
     const parts = [];
     if (deadCount > 0)
         parts.push(`${deadCount} 个死链接`);
     if (formatCount > 0)
         parts.push(`${formatCount} 个路径格式问题`);
+    if (boundaryCount > 0)
+        parts.push(`${boundaryCount} 个跨边界引用`);
     lines.push(`发现 ${issues.length} 个问题（${parts.join('，')}），涉及 ${grouped.size} 个文件。`);
     return lines.join('\n');
 }

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, { aigc: true });
+    const markdownFiles = await (0, findEntries_1.findEntries)(paths_1.INPUT_DIR, { aigc: true });
     for (const filePath of markdownFiles) {
         queue.push(filePath);
     }

package/dist/process/todoSummary.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTodoSummary = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const metadata_1 = require("../metadata");
+const paths_1 = require("../paths");
+const opencode_1 = require("../services/opencode");
+// Prompt 模板目录路径
+const PROMPTS_DIR = (0, path_1.join)(__dirname, '../../prompts');
+// 最大重试次数
+const MAX_RETRIES = 3;
+// TODO Summary 配置
+const TODO_CONFIG = {
+    promptFile: 'todo-summary',
+    title: 'AI 总结：待办事项',
+    slug: 'aigc-todo-list',
+    outputRelative: '.czon/AIGC/TODO/todo-summary.md',
+};
+/**
+ * 读取 Prompt 模板文件内容
+ */
+const loadPromptTemplate = async (templateName) => {
+    const templatePath = (0, path_1.join)(PROMPTS_DIR, `${templateName}.md`);
+    return (0, promises_1.readFile)(templatePath, 'utf-8');
+};
+/**
+ * 获取文件的 mtime（毫秒），文件不存在则返回 null
+ */
+const getFileMtimeMs = async (filePath) => {
+    try {
+        const s = await (0, promises_1.stat)(filePath);
+        return s.mtimeMs;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * 生成 TODO Summary 报告
+ */
+const processTodoSummary = async (model) => {
+    const cwd = process.cwd();
+    // 加载 MetaData
+    await (0, metadata_1.loadMetaData)();
+    // 加载 prompt 模板
+    console.info('📖 加载 TODO Summary prompt 模板...');
+    const promptContent = await loadPromptTemplate(TODO_CONFIG.promptFile);
+    const outputPath = (0, path_1.join)(paths_1.INPUT_DIR, TODO_CONFIG.outputRelative);
+    const prompt = `
+${promptContent}
+
+---
+
+# 执行任务
+
+请严格按照上述指南，阅读本仓库中的所有 Markdown 文件，提取所有 TODO 项，生成待办事项报告。
+
+输出文件：${TODO_CONFIG.outputRelative}
+
+注意：
+1. 必须阅读所有文件后再生成报告
+2. 文件必须保存到 ${TODO_CONFIG.outputRelative}
+3. 确保所有链接使用 ../../../ 开头的相对路径
+4. 链接文本使用文章标题
+`.trim();
+    // 记录发送前的 mtime
+    const mtimeBefore = await getFileMtimeMs(outputPath);
+    console.info('\n📊 开始生成 TODO Summary 报告...\n');
+    // 发送初始 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) {
+            console.info('✅ TODO Summary 报告生成成功\n');
+            // 预设 title 和 slug 到 MetaData
+            let fileMeta = metadata_1.MetaData.files.find(f => f.path === TODO_CONFIG.outputRelative);
+            if (!fileMeta) {
+                fileMeta = { path: TODO_CONFIG.outputRelative, links: [] };
+                metadata_1.MetaData.files.push(fileMeta);
+            }
+            fileMeta.metadata = {
+                ...fileMeta.metadata,
+                title: TODO_CONFIG.title,
+                slug: TODO_CONFIG.slug,
+            };
+            // 保存 MetaData
+            await (0, metadata_1.saveMetaData)();
+            return;
+        }
+        // 构造错误反馈
+        let errorMsg;
+        if (!fileExists) {
+            errorMsg = `错误：文件 ${TODO_CONFIG.outputRelative} 未生成。请立即创建并写入完整的报告内容到 ${TODO_CONFIG.outputRelative}。`;
+        }
+        else {
+            errorMsg = `错误：文件 ${TODO_CONFIG.outputRelative} 未被修改。请重新生成完整内容并覆盖写入 ${TODO_CONFIG.outputRelative}。`;
+        }
+        console.warn(`  ⚠️ 重试 ${attempt}/${MAX_RETRIES}: ${errorMsg}`);
+        await handle.prompt(errorMsg);
+    }
+    // 最终检查
+    const mtimeFinal = await getFileMtimeMs(outputPath);
+    if (mtimeFinal !== null && mtimeBefore !== mtimeFinal) {
+        console.info('✅ TODO Summary 报告生成成功（最终检查通过）\n');
+        // 预设 title 和 slug 到 MetaData
+        let fileMeta = metadata_1.MetaData.files.find(f => f.path === TODO_CONFIG.outputRelative);
+        if (!fileMeta) {
+            fileMeta = { path: TODO_CONFIG.outputRelative, links: [] };
+            metadata_1.MetaData.files.push(fileMeta);
+        }
+        fileMeta.metadata = {
+            ...fileMeta.metadata,
+            title: TODO_CONFIG.title,
+            slug: TODO_CONFIG.slug,
+        };
+        await (0, metadata_1.saveMetaData)();
+        return;
+    }
+    throw new Error(`${MAX_RETRIES} 次重试后仍未成功生成文件: ${TODO_CONFIG.outputRelative}`);
+};
+exports.processTodoSummary = processTodoSummary;
+//# sourceMappingURL=todoSummary.js.map

package/package.json

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

package/prompts/summary-base.md

@@ -115,20 +115,20 @@
 - 引用原文链接时，保证链接有效
 - **永远链接到具体的 Markdown 文件**，不要链接目录
 - **链接文本应当是对应的标题**，而不是文件名
-- 由于生成到 SUMMARY 目录，引用时使用 `../` 开头的相对路径
+- 由于生成到 `.czon/AIGC/SUMMARY/` 目录，引用时使用 `../../../` 开头的相对路径
 
 **正确示例**：
 
 ```markdown
-[资本持久战：个人投资者跨越阶级的战略](../INSIGHTS/6.md)
-[从创作到分发——构建AI-Native内容引擎](../INSIGHTS/4.md)
+[资本持久战：个人投资者跨越阶级的战略](../../../INSIGHTS/6.md)
+[从创作到分发——构建AI-Native内容引擎](../../../INSIGHTS/4.md)
 ```
 
 **错误示例**：
 
 ```markdown
-[INSIGHTS/6.md](../INSIGHTS/6.md) ← 使用了文件名而非标题
-[资本持久战](../INSIGHTS/) ← 链接到了目录
+[INSIGHTS/6.md](../../../INSIGHTS/6.md) ← 使用了文件名而非标题
+[资本持久战](../../../INSIGHTS/) ← 链接到了目录
 ```
 
 ### 3. 头部格式

package/prompts/todo-summary.md

@@ -0,0 +1,244 @@
+# TODO 待办事项提取报告
+
+## 文档阅读流程（必须严格遵循）
+
+### 核心原则
+
+本仓库可能包含成百上千个 Markdown 文件。你必须**逐一阅读每个文件**，不得跳过。
+为了处理大量文件，采用**渐进式阅读与摘要**策略。
+
+### 阶段 1：获取完整文件列表
+
+1. 执行 `npx czon@latest ls-files` 获取所有 Markdown 文件
+2. 记录文件总数 N
+3. 将文件列表保存为待阅读队列
+
+### 阶段 2：分批阅读与提取
+
+将文件分批处理。建议每批 10-20 个文件，但你可以根据文件大小和复杂度自行调整。
+
+**对于每一批：**
+
+1. **阅读**：使用 Read 工具逐一读取该批次的每个文件完整内容
+2. **提取 TODO**：根据下方「TODO 提取规则」，识别并记录所有 TODO 项
+3. **批次汇总**：将该批次提取的 TODO 项整理到「TODO 知识库」中
+4. **累积**：将批次结果合并到全局 TODO 知识库
+
+### 阶段 3：上下文管理
+
+当上下文接近限制时：
+
+1. **压缩知识库**：已提取的 TODO 条目保留核心信息（描述、来源文件、状态），丢弃详细原文引用
+2. **保留索引**：无论如何压缩，必须保留所有文件的路径和标题索引
+3. **继续阅读**：使用压缩后的知识库继续处理剩余文件
+
+### 阶段 4：完整性验证
+
+在生成报告前，必须确认：
+
+1. 文件列表中的所有 N 个文件都已处理
+2. 所有提取的 TODO 项都有明确的来源文件
+
+**如果发现遗漏**：返回阶段 2 处理遗漏的文件。
+
+---
+
+## TODO 提取规则
+
+### 显式 TODO
+
+文中明确表达待办意图的内容，包括但不限于以下标志词：
+
+- "TODO"、"FIXME"、"HACK"
+- "待办"、"待完成"、"待处理"、"待实现"
+- "计划做"、"计划实现"、"计划添加"
+- "接下来要做"、"接下来要"、"下一步"
+- "需要实现"、"需要添加"、"需要完成"、"需要解决"
+
+### 隐式 TODO
+
+文中表达了意图或规划但尚未明确完成的事项：
+
+- "我会..."、"我打算..."、"我准备..."
+- "应该..."、"需要一个..."
+- "未来会..."、"之后会..."
+- "还没有..."、"暂时没有..."
+- 描述了一个功能设想但没有实现的迹象
+
+### 提取要素
+
+对每个识别到的 TODO 项，记录以下信息：
+
+| 字段     | 说明                                 |
+| -------- | ------------------------------------ |
+| 描述     | TODO 的简短描述（一句话概括）        |
+| 来源文件 | 文件路径和文章标题                   |
+| 原文引用 | 相关原文片段（1-2 句话）             |
+| 推断日期 | 该 TODO 提出的日期（从文章内容推断） |
+
+---
+
+## 状态判断规则
+
+通过交叉对比多篇文章内容，判断每个 TODO 的当前状态：
+
+### ✅ 已完成
+
+- 后续文章中明确提到「已完成」「已实现」「已上线」「已解决」
+- 在代码库或产品中可以观察到相关功能已存在
+- 相关问题在后续文章中不再被提及，且有明确的解决迹象
+
+### 🔄 进行中
+
+- 后续文章中提到正在做、有部分进展
+- 存在相关的中间产物（如设计文档、原型）但未完全完成
+- 最近的文章中仍在讨论相关内容
+
+### ⬜ 待开始
+
+- 仅提出了计划或想法，未见任何后续进展
+- 没有在其他文章中被再次提及
+- 明确标注为未来计划
+
+---
+
+## 优先级标记规则
+
+基于文章内容体现的作者价值观和关注领域，自动判断优先级：
+
+### 🔴 高优先级
+
+- 与核心业务目标直接相关：创业、投资、产品发布、收入目标
+- 与正在活跃开发的项目直接相关（如 CZON、CZONE、EA 等）
+- 作者在文中明确表达了紧迫感或重要性
+- 阻塞其他工作的关键任务
+
+### 🟡 中优先级
+
+- 技术改进、工具优化、流程提升
+- 对产品质量有正面影响但非紧急
+- 作者表达了兴趣但没有明确时间要求
+
+### 🟢 低优先级
+
+- 探索性想法、研究性质的思考
+- 非紧急的改进建议
+- 「有空再做」类的想法
+- 纯学习或实验目的
+
+---
+
+## 输出格式
+
+### 头部格式
+
+```markdown
+# AI 总结：待办事项
+
+**AI 分析时间**：YYYY年MM月DD日
+**基于 N 个 Markdown 文件生成**
+**注**：本报告由 AI 自动提取，状态和优先级为 AI 推断结果，仅供参考。
+
+---
+```
+
+其中 `N` 为阶段 1 中获取到的实际 Markdown 文件总数。
+
+### 概览
+
+```markdown
+## 概览
+
+| 状态      | 数量  |
+| --------- | ----- |
+| ⬜ 待开始 | X     |
+| 🔄 进行中 | X     |
+| ✅ 已完成 | X     |
+| **总计**  | **X** |
+```
+
+### TODO 列表
+
+按状态分组展示，每组内部按优先级排序（高 → 中 → 低）：
+
+```markdown
+## ⬜ 待开始
+
+### 🔴 [TODO 简短描述]
+
+- **来源**：[文章标题](../../../path/to/file.md)
+- **日期**：YYYY-MM-DD
+- **原文**：
+  > 引用相关原文片段
+
+---
+
+### 🟡 [TODO 简短描述]
+
+...
+
+## 🔄 进行中
+
+...
+
+## ✅ 已完成
+
+...
+```
+
+---
+
+## 引用链接规范
+
+- 引用原文链接时，保证链接有效
+- **永远链接到具体的 Markdown 文件**，不要链接目录
+- **链接文本应当是对应的标题**，而不是文件名
+- 由于生成到 `.czon/AIGC/TODO/` 目录，引用时使用 `../../../` 开头的相对路径
+
+**正确示例**：
+
+```markdown
+[资本持久战：个人投资者跨越阶级的战略](../../../INSIGHTS/6.md)
+```
+
+**错误示例**：
+
+```markdown
+[INSIGHTS/6.md](../../../INSIGHTS/6.md) ← 使用了文件名而非标题
+```
+
+---
+
+## 分段写入规则
+
+由于报告内容可能很长，**必须分段写入**，禁止一次性写入整个报告。
+
+### 步骤 1：写入骨架文件
+
+首先创建报告文件，写入头部、概览占位、各状态章节标题和占位标记。
+
+### 步骤 2：逐章节填充内容
+
+按章节顺序，逐一替换占位标记为实际内容：
+
+1. 每次只填充**一个章节**的内容
+2. 单次写入内容控制在 **2000 字以内**
+3. 如果某个章节超过 2000 字，拆分为多次写入
+
+### 步骤 3：完整性检查
+
+所有章节填充完毕后：
+
+1. 读取完整文件，确认无遗漏的占位标记
+2. 确认所有链接格式正确
+3. 确认概览中的统计数字与实际 TODO 数量一致
+
+---
+
+## 禁止行为
+
+- ❌ 不得在阅读完所有文件前开始生成报告
+- ❌ 不得跳过任何文件
+- ❌ 不得虚构不存在的 TODO 项
+- ❌ 不得虚构完成状态（无法判断时标记为「待开始」）
+- ❌ 不得遗漏明确标记的 TODO（如文中出现 "TODO" 字样的条目）