cc-devflow 4.1.1 → 4.1.3

package/lib/compiler/__tests__/multi-module-emitters.test.js

@@ -213,9 +213,10 @@ describe('CodexEmitter Multi-Module', () => {
     expect(content).toContain('## Required Context');
   });
 
-  test('emitAgents merges to AGENTS.md', async () => {
+  test('emitAgents writes compact managed block and preserves existing content', async () => {
     const sourceDir = path.join(tempDir, '.claude', 'agents');
     const targetPath = path.join(tempDir, 'AGENTS.md');
+    fs.writeFileSync(targetPath, '# User Memory\n\nDo not overwrite this.\n');
 
     const results = await emitter.emitAgents(sourceDir, targetPath);
 
@@ -223,25 +224,32 @@ describe('CodexEmitter Multi-Module', () => {
     expect(fs.existsSync(targetPath)).toBe(true);
 
     const content = fs.readFileSync(targetPath, 'utf8');
-    expect(content).toContain('# Agents');
-    expect(content).toContain('## test-agent');
+    expect(content).toContain('# User Memory');
+    expect(content).toContain('<!-- cc-devflow:codex-agents:start -->');
+    expect(content).toContain('## CC-DevFlow Agents');
+    expect(content).toContain('- Count: 1');
+    expect(content).not.toContain('This agent is for testing.');
   });
 
-  test('emitRules appends to AGENTS.md', async () => {
+  test('emitRules writes compact managed block and remains idempotent', async () => {
     const sourceDir = path.join(tempDir, '.claude', 'rules');
     const targetPath = path.join(tempDir, 'AGENTS.md');
 
-    // 先创建 AGENTS.md
-    fs.writeFileSync(targetPath, '# Agents\n\nExisting content.\n');
+    fs.writeFileSync(targetPath, '# User Memory\n\nKeep me.\n');
 
-    const results = await emitter.emitRules(sourceDir, targetPath);
+    const first = await emitter.emitRules(sourceDir, targetPath);
+    const second = await emitter.emitRules(sourceDir, targetPath);
 
-    expect(results.length).toBe(1);
+    expect(first.length).toBe(1);
+    expect(second.length).toBe(1);
 
     const content = fs.readFileSync(targetPath, 'utf8');
-    expect(content).toContain('# Agents');
-    expect(content).toContain('## Rules');
-    expect(content).toContain('### test-rule');
+    expect(content).toContain('# User Memory');
+    expect(content).toContain('<!-- cc-devflow:codex-rules:start -->');
+    expect(content).toContain('## CC-DevFlow Rules');
+    expect(content).toContain('- Count: 1');
+    expect(content).not.toContain('This rule is for testing.');
+    expect(content.split('<!-- cc-devflow:codex-rules:start -->').length - 1).toBe(1);
   });
 });
 
@@ -428,6 +436,24 @@ describe('AntigravityEmitter Multi-Module', () => {
     const targetPath = path.join(targetDir, 'test-rule.md');
     expect(fs.existsSync(targetPath)).toBe(true);
   });
+
+  test('emitAgents writes compact managed block and preserves existing content', async () => {
+    const sourceDir = path.join(tempDir, '.claude', 'agents');
+    const targetPath = path.join(tempDir, 'AGENTS.md');
+    fs.writeFileSync(targetPath, '# User Memory\n\nKeep this section.\n');
+
+    const results = await emitter.emitAgents(sourceDir, targetPath);
+
+    expect(results.length).toBe(1);
+    expect(fs.existsSync(targetPath)).toBe(true);
+
+    const content = fs.readFileSync(targetPath, 'utf8');
+    expect(content).toContain('# User Memory');
+    expect(content).toContain('<!-- cc-devflow:antigravity-agents:start -->');
+    expect(content).toContain('## CC-DevFlow Agents');
+    expect(content).toContain('- Count: 1');
+    expect(content).not.toContain('This agent is for testing.');
+  });
 });
 
 // ============================================================

package/lib/compiler/__tests__/parser.test.js

@@ -452,5 +452,51 @@ Body`);
         fs.rmdirSync(tmpDir);
       }
     });
+
+    it('should parse nested command files recursively', async () => {
+      const tmpDir = path.join(os.tmpdir(), `test-nested-${Date.now()}`);
+      const flowDir = path.join(tmpDir, 'flow');
+      const utilDir = path.join(tmpDir, 'util');
+      fs.mkdirSync(flowDir, { recursive: true });
+      fs.mkdirSync(utilDir, { recursive: true });
+
+      fs.writeFileSync(path.join(flowDir, 'new.md'), `---
+name: flow-new
+description: Flow new command
+---
+Body`);
+      fs.writeFileSync(path.join(utilDir, 'code-review.md'), `---
+name: code-review
+description: Code review command
+---
+Body`);
+
+      try {
+        const result = await parser.parseAllCommands(tmpDir);
+        expect(result).toHaveLength(2);
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('should preserve relative subpath in source filename', async () => {
+      const tmpDir = path.join(os.tmpdir(), `test-relpath-${Date.now()}`);
+      const flowDir = path.join(tmpDir, 'flow');
+      fs.mkdirSync(flowDir, { recursive: true });
+
+      fs.writeFileSync(path.join(flowDir, 'spec.md'), `---
+name: flow-spec
+description: Flow spec command
+---
+Body`);
+
+      try {
+        const result = await parser.parseAllCommands(tmpDir);
+        expect(result).toHaveLength(1);
+        expect(result[0].source.filename).toBe('flow/spec');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
   });
 });

package/lib/compiler/__tests__/resource-copier.test.js

@@ -0,0 +1,26 @@
+/**
+ * T044: Resource Copier Tests
+ *
+ * [INPUT]: 内联路径字符串
+ * [OUTPUT]: scanInlineClaudePaths 扫描结果
+ * [POS]: 资源扫描单元测试，防止 glob 误判为文件
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const { scanInlineClaudePaths } = require('../resource-copier.js');
+
+describe('resource-copier', () => {
+  test('scanInlineClaudePaths should skip glob patterns', () => {
+    const content = 'Templates: .claude/docs/templates/context/*.jsonl.template';
+    const paths = scanInlineClaudePaths(content);
+
+    expect(paths).toEqual([]);
+  });
+
+  test('scanInlineClaudePaths should keep concrete file paths', () => {
+    const content = 'Use .claude/scripts/check-prerequisites.sh before execution.';
+    const paths = scanInlineClaudePaths(content);
+
+    expect(paths).toContain('.claude/scripts/check-prerequisites.sh');
+  });
+});

package/lib/compiler/__tests__/skill-discovery.test.js

@@ -0,0 +1,72 @@
+/**
+ * T042: Skill Discovery Tests
+ *
+ * [INPUT]: 临时技能目录结构
+ * [OUTPUT]: 递归扫描结果断言
+ * [POS]: skill-discovery 单元测试，验证分组/非分组技能发现
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { discoverSkillEntries } = require('../skill-discovery.js');
+const { generateSkillsRegistryV2 } = require('../skills-registry.js');
+
+function setupSkillsFixture(rootDir) {
+  // 非分组技能
+  const rootSkillDir = path.join(rootDir, 'orchestrator');
+  fs.mkdirSync(rootSkillDir, { recursive: true });
+  fs.writeFileSync(path.join(rootSkillDir, 'SKILL.md'), `---
+name: orchestrator
+description: Root level skill
+---`);
+
+  // 分组技能
+  const groupedSkillDir = path.join(rootDir, 'workflow', 'flow-dev');
+  fs.mkdirSync(groupedSkillDir, { recursive: true });
+  fs.writeFileSync(path.join(groupedSkillDir, 'SKILL.md'), `---
+name: flow-dev
+description: Grouped workflow skill
+---`);
+
+  // 需要跳过的目录
+  const ignoredSkillDir = path.join(rootDir, '_reference', 'demo-skill');
+  fs.mkdirSync(ignoredSkillDir, { recursive: true });
+  fs.writeFileSync(path.join(ignoredSkillDir, 'SKILL.md'), `---
+name: demo-skill
+description: Should be ignored
+---`);
+}
+
+describe('skill-discovery', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-discovery-'));
+    setupSkillsFixture(tempDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test('discoverSkillEntries should include grouped and root skills', () => {
+    const entries = discoverSkillEntries(tempDir);
+    const names = entries.map(entry => entry.name);
+
+    expect(names).toContain('orchestrator');
+    expect(names).toContain('flow-dev');
+    expect(names).not.toContain('demo-skill');
+  });
+
+  test('generateSkillsRegistryV2 should register grouped and root skills', async () => {
+    const registry = await generateSkillsRegistryV2(tempDir);
+    const names = registry.skills.map(skill => skill.name);
+
+    expect(names).toContain('orchestrator');
+    expect(names).toContain('flow-dev');
+    expect(names).not.toContain('demo-skill');
+  });
+});

package/lib/compiler/emitters/antigravity-emitter.js

@@ -9,7 +9,7 @@
  * 输出格式:
  * - Commands: Markdown + YAML frontmatter -> .agent/workflows/
  * - Skills: SKILL.md (YAML frontmatter) -> .agent/skills/
- * - Agents: 合并到 AGENTS.md
+ * - Agents: 索引摘要写入 AGENTS.md（保留用户内容）
  * - Rules: Markdown -> .agent/rules/
  *
  * 限制: 单文件 <= 12,000 字符，超限时自动拆分
@@ -22,6 +22,7 @@ const yaml = require('js-yaml');
 const matter = require('gray-matter');
 const BaseEmitter = require('./base-emitter.js');
 const { ContextExpander } = require('../context-expander.js');
+const { discoverSkillEntries } = require('../skill-discovery.js');
 
 const CONTENT_LIMIT = 12000;
 const DESCRIPTION_LIMIT = 250;
@@ -196,40 +197,19 @@ class AntigravityEmitter extends BaseEmitter {
       return results;
     }
 
-    // 扫描技能分组目录
-    const groupDirs = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const groupEntry of groupDirs) {
-      if (!groupEntry.isDirectory() || groupEntry.name.startsWith('_')) {
-        continue;
-      }
-
-      const groupDir = path.join(sourceDir, groupEntry.name);
-      const skillEntries = await fs.promises.readdir(groupDir, { withFileTypes: true });
-
-      for (const skillEntry of skillEntries) {
-        if (!skillEntry.isDirectory() || skillEntry.name.startsWith('_')) {
-          continue;
-        }
-
-        const skillDir = path.join(groupDir, skillEntry.name);
-        const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-        if (!fs.existsSync(skillMdPath)) {
-          continue;
-        }
-
-        try {
-          const result = await this._emitSingleSkill(
-            skillEntry.name,
-            skillDir,
-            skillMdPath,
-            targetDir
-          );
-          results.push(result);
-        } catch (error) {
-          console.warn(`Warning: Failed to emit skill ${skillEntry.name}: ${error.message}`);
-        }
+    const skills = discoverSkillEntries(sourceDir);
+
+    for (const skill of skills) {
+      try {
+        const result = await this._emitSingleSkill(
+          skill.name,
+          skill.skillDir,
+          skill.skillMdPath,
+          targetDir
+        );
+        results.push(result);
+      } catch (error) {
+        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
       }
     }
 
@@ -278,7 +258,12 @@ class AntigravityEmitter extends BaseEmitter {
     const result = await this.emitToPath(targetPath, finalContent);
 
     // 复制 scripts/ 和 references/ 目录
-    await this._copySkillResources(skillDir, targetSkillDir);
+    try {
+      await this._copySkillResources(skillDir, targetSkillDir);
+    } catch (error) {
+      // 资源复制失败不阻塞主 SKILL.md 产物
+      console.warn(`Warning: Failed to copy resources for skill ${skillName}: ${error.message}`);
+    }
 
     return { ...result, skillName };
   }
@@ -287,7 +272,7 @@ class AntigravityEmitter extends BaseEmitter {
    * 复制 Skill 资源目录
    */
   async _copySkillResources(sourceSkillDir, targetSkillDir) {
-    const resourceDirs = ['scripts', 'references', 'examples', 'resources'];
+    const resourceDirs = ['scripts', 'references', 'assets', 'examples', 'resources'];
 
     for (const dir of resourceDirs) {
       const sourceResDir = path.join(sourceSkillDir, dir);
@@ -312,6 +297,20 @@ class AntigravityEmitter extends BaseEmitter {
 
       if (entry.isDirectory()) {
         await this._copyDir(srcPath, destPath);
+      } else if (entry.isSymbolicLink()) {
+        try {
+          const resolvedPath = await fs.promises.realpath(srcPath);
+          const resolvedStats = await fs.promises.stat(resolvedPath);
+          await fs.promises.rm(destPath, { force: true, recursive: true });
+
+          if (resolvedStats.isDirectory()) {
+            await this._copyDir(resolvedPath, destPath);
+          } else {
+            await fs.promises.copyFile(resolvedPath, destPath);
+          }
+        } catch (error) {
+          console.warn(`Warning: Skip broken symlink ${srcPath}: ${error.message}`);
+        }
       } else {
         await fs.promises.copyFile(srcPath, destPath);
       }
@@ -320,10 +319,29 @@ class AntigravityEmitter extends BaseEmitter {
 
   /**
    * 编译 Agents 模块
-   * .claude/agents/[name].md -> AGENTS.md (合并)
+   * .claude/agents/[name].md -> AGENTS.md (短索引，受管块)
    */
   async emitAgents(sourceDir, targetPath) {
-    return this._defaultAgentsEmit(sourceDir, targetPath);
+    const results = [];
+    const agentNames = await this.readMarkdownEntryNames(sourceDir);
+
+    if (agentNames.length === 0) {
+      return results;
+    }
+
+    const summary = [
+      '## CC-DevFlow Agents',
+      '',
+      '- Scope: `.claude/agents/*.md`',
+      `- Count: ${agentNames.length}`,
+      `- Entries: ${this.formatCompactList(agentNames)}`,
+      '- Policy: Keep AGENTS.md concise; detailed agent instructions stay in source files.'
+    ].join('\n');
+
+    const result = await this.upsertManagedBlock(targetPath, 'antigravity-agents', summary);
+    results.push({ ...result, count: agentNames.length });
+
+    return results;
   }
 
   /**

package/lib/compiler/emitters/base-emitter.js

@@ -23,6 +23,7 @@ const crypto = require('crypto');
 // SECURITY CONFIGURATION (FINDING-003)
 // ============================================================
 const MAX_OUTPUT_SIZE = 2 * 1024 * 1024; // 2MB limit
+const MANAGED_BLOCK_PREFIX = 'cc-devflow';
 
 // ============================================================
 // MODULE_TYPES - 支持的模块类型
@@ -70,9 +71,11 @@ class BaseEmitter {
     const outputDir = this.outputDir;
     const ext = this.fileExtension;
     const filePath = path.join(outputDir, `${filename}${ext}`);
+    const fileDir = path.dirname(filePath);
 
     // ✅ SECURITY FIX (FINDING-005): Set explicit directory permissions
-    await fs.promises.mkdir(outputDir, { recursive: true, mode: 0o755 });
+    // 支持带子路径的文件名（例如 flow/new）
+    await fs.promises.mkdir(fileDir, { recursive: true, mode: 0o755 });
 
     // ✅ SECURITY FIX (FINDING-005): Set explicit file permissions
     await fs.promises.writeFile(filePath, content, { encoding: 'utf8', mode: 0o644 });
@@ -282,6 +285,83 @@ class BaseEmitter {
   hashContent(content) {
     return crypto.createHash('sha256').update(content).digest('hex');
   }
+
+  /**
+   * 读取目录下的 Markdown 文件名（去掉 .md）
+   */
+  async readMarkdownEntryNames(sourceDir) {
+    if (!fs.existsSync(sourceDir)) {
+      return [];
+    }
+
+    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+
+    return entries
+      .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+      .map(entry => entry.name.replace(/\.md$/, ''))
+      .sort((a, b) => a.localeCompare(b));
+  }
+
+  /**
+   * 格式化短列表，避免全局记忆文件过长
+   */
+  formatCompactList(items, maxItems = 12) {
+    if (!items || items.length === 0) {
+      return '`(none)`';
+    }
+
+    const visible = items.slice(0, maxItems).map(item => `\`${item}\``);
+    const hiddenCount = items.length - visible.length;
+
+    if (hiddenCount > 0) {
+      visible.push(`... (+${hiddenCount} more)`);
+    }
+
+    return visible.join(', ');
+  }
+
+  /**
+   * 受管块写入：仅替换指定区块，保留用户原有内容
+   */
+  async upsertManagedBlock(targetPath, blockId, body) {
+    const startMarker = `<!-- ${MANAGED_BLOCK_PREFIX}:${blockId}:start -->`;
+    const endMarker = `<!-- ${MANAGED_BLOCK_PREFIX}:${blockId}:end -->`;
+    const managedBlock = `${startMarker}\n${body.trim()}\n${endMarker}`;
+
+    let existing = '';
+    if (fs.existsSync(targetPath)) {
+      existing = await fs.promises.readFile(targetPath, 'utf8');
+    }
+
+    const merged = this._replaceManagedBlock(existing, startMarker, endMarker, managedBlock);
+    return this.emitToPath(targetPath, merged);
+  }
+
+  _replaceManagedBlock(existing, startMarker, endMarker, managedBlock) {
+    const startIndex = existing.indexOf(startMarker);
+    const endIndex = existing.indexOf(endMarker);
+
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+      const before = existing.slice(0, startIndex).trimEnd();
+      const after = existing.slice(endIndex + endMarker.length).trimStart();
+
+      return this._joinBlocks(before, managedBlock, after);
+    }
+
+    if (!existing.trim()) {
+      return `${managedBlock}\n`;
+    }
+
+    return `${existing.trimEnd()}\n\n${managedBlock}\n`;
+  }
+
+  _joinBlocks(...blocks) {
+    const validBlocks = blocks.filter(block => block && block.trim().length > 0);
+    if (validBlocks.length === 0) {
+      return '';
+    }
+    return `${validBlocks.join('\n\n')}\n`;
+  }
 }
 
 module.exports = BaseEmitter;

package/lib/compiler/emitters/codex-emitter.js

@@ -9,8 +9,8 @@
  * 输出格式:
  * - Commands: Markdown + YAML frontmatter → .codex/prompts/
  * - Skills: SKILL.md (YAML frontmatter) → .codex/skills/
- * - Agents: 合并到 AGENTS.md
- * - Rules: 合并到 AGENTS.md
+ * - Agents: 索引摘要写入 AGENTS.md（保留用户内容）
+ * - Rules: 索引摘要写入 AGENTS.md（保留用户内容）
  *
  * v2.0: 支持多模块编译
  */
@@ -20,6 +20,7 @@ const yaml = require('js-yaml');
 const matter = require('gray-matter');
 const BaseEmitter = require('./base-emitter.js');
 const { ContextExpander } = require('../context-expander.js');
+const { discoverSkillEntries } = require('../skill-discovery.js');
 
 class CodexEmitter extends BaseEmitter {
   get name() {
@@ -76,40 +77,19 @@ class CodexEmitter extends BaseEmitter {
       return results;
     }
 
-    // 扫描技能分组目录 (workflow/, domain/, utility/, guardrail/)
-    const groupDirs = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-
-    for (const groupEntry of groupDirs) {
-      if (!groupEntry.isDirectory() || groupEntry.name.startsWith('_')) {
-        continue;
-      }
-
-      const groupDir = path.join(sourceDir, groupEntry.name);
-      const skillEntries = await fs.promises.readdir(groupDir, { withFileTypes: true });
-
-      for (const skillEntry of skillEntries) {
-        if (!skillEntry.isDirectory() || skillEntry.name.startsWith('_')) {
-          continue;
-        }
-
-        const skillDir = path.join(groupDir, skillEntry.name);
-        const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-        if (!fs.existsSync(skillMdPath)) {
-          continue;
-        }
-
-        try {
-          const result = await this._emitSingleSkill(
-            skillEntry.name,
-            skillDir,
-            skillMdPath,
-            targetDir
-          );
-          results.push(result);
-        } catch (error) {
-          console.warn(`Warning: Failed to emit skill ${skillEntry.name}: ${error.message}`);
-        }
+    const skills = discoverSkillEntries(sourceDir);
+
+    for (const skill of skills) {
+      try {
+        const result = await this._emitSingleSkill(
+          skill.name,
+          skill.skillDir,
+          skill.skillMdPath,
+          targetDir
+        );
+        results.push(result);
+      } catch (error) {
+        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
       }
     }
 
@@ -153,7 +133,12 @@ class CodexEmitter extends BaseEmitter {
     const result = await this.emitToPath(targetPath, finalContent);
 
     // 复制 scripts/ 和 references/ 目录
-    await this._copySkillResources(skillDir, targetSkillDir);
+    try {
+      await this._copySkillResources(skillDir, targetSkillDir);
+    } catch (error) {
+      // 资源复制失败不阻塞主 SKILL.md 产物
+      console.warn(`Warning: Failed to copy resources for skill ${skillName}: ${error.message}`);
+    }
 
     return { ...result, skillName };
   }
@@ -187,6 +172,20 @@ class CodexEmitter extends BaseEmitter {
 
       if (entry.isDirectory()) {
         await this._copyDir(srcPath, destPath);
+      } else if (entry.isSymbolicLink()) {
+        try {
+          const resolvedPath = await fs.promises.realpath(srcPath);
+          const resolvedStats = await fs.promises.stat(resolvedPath);
+          await fs.promises.rm(destPath, { force: true, recursive: true });
+
+          if (resolvedStats.isDirectory()) {
+            await this._copyDir(resolvedPath, destPath);
+          } else {
+            await fs.promises.copyFile(resolvedPath, destPath);
+          }
+        } catch (error) {
+          console.warn(`Warning: Skip broken symlink ${srcPath}: ${error.message}`);
+        }
       } else {
         await fs.promises.copyFile(srcPath, destPath);
       }
@@ -195,51 +194,54 @@ class CodexEmitter extends BaseEmitter {
 
   /**
    * 编译 Agents 模块
-   * .claude/agents/[name].md -> AGENTS.md (合并)
+   * .claude/agents/[name].md -> AGENTS.md (短索引，受管块)
    */
   async emitAgents(sourceDir, targetPath) {
-    return this._defaultAgentsEmit(sourceDir, targetPath);
+    const results = [];
+    const agentNames = await this.readMarkdownEntryNames(sourceDir);
+
+    if (agentNames.length === 0) {
+      return results;
+    }
+
+    const summary = [
+      '## CC-DevFlow Agents',
+      '',
+      '- Scope: `.claude/agents/*.md`',
+      `- Count: ${agentNames.length}`,
+      `- Entries: ${this.formatCompactList(agentNames)}`,
+      '- Policy: Keep AGENTS.md concise as global memory; full agent specs stay in source files.'
+    ].join('\n');
+
+    const result = await this.upsertManagedBlock(targetPath, 'codex-agents', summary);
+    results.push({ ...result, count: agentNames.length });
+
+    return results;
   }
 
   /**
    * 编译 Rules 模块
-   * .claude/rules/[name].md -> AGENTS.md (追加)
+   * .claude/rules/[name].md -> AGENTS.md (短索引，受管块)
    */
   async emitRules(sourceDir, targetPath) {
     const results = [];
+    const ruleNames = await this.readMarkdownEntryNames(sourceDir);
 
-    if (!fs.existsSync(sourceDir)) {
+    if (ruleNames.length === 0) {
       return results;
     }
 
-    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
-    const sections = [];
-
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.endsWith('.md')) {
-        continue;
-      }
-
-      const filePath = path.join(sourceDir, entry.name);
-      const content = await fs.promises.readFile(filePath, 'utf8');
-      const ruleName = entry.name.replace('.md', '');
-
-      sections.push(`### ${ruleName}\n\n${content}`);
-    }
-
-    if (sections.length > 0) {
-      // 追加到现有 AGENTS.md
-      let existingContent = '';
-      if (fs.existsSync(targetPath)) {
-        existingContent = await fs.promises.readFile(targetPath, 'utf8');
-      }
-
-      const rulesSection = `\n\n## Rules\n\n${sections.join('\n\n---\n\n')}`;
-      const merged = existingContent + rulesSection;
-
-      const result = await this.emitToPath(targetPath, merged);
-      results.push(result);
-    }
+    const summary = [
+      '## CC-DevFlow Rules',
+      '',
+      '- Scope: `.claude/rules/*.md`',
+      `- Count: ${ruleNames.length}`,
+      `- Entries: ${this.formatCompactList(ruleNames)}`,
+      '- Policy: AGENTS.md stores only memory-level constraints, not full rule bodies.'
+    ].join('\n');
+
+    const result = await this.upsertManagedBlock(targetPath, 'codex-rules', summary);
+    results.push({ ...result, count: ruleNames.length });
 
     return results;
   }