cc-devflow 4.1.1 → 4.1.2

package/.claude/commands/util/git-commit.md

@@ -4,9 +4,6 @@ description: Git Commit 工作流最佳实践 - Conventional Commits 规范、
 version: 3.0.0
 author: CC-DevFlow
 updated_at: 2026-01-04
-scripts:
-  review: .claude/scripts/git-commit-review.sh
-  pr_check: .claude/scripts/check-remote.sh
 ---
 
 > **哲学核心**：Commit 是代码历史的节点，每个节点都应该清晰、独立、可追溯。
@@ -422,4 +419,4 @@ git show <commit-hash>
 
 ---
 
-**记住**：好的 commit 历史是项目最好的文档。代码是写给人看的，只是顺便让机器运行。
+**记住**：好的 commit 历史是项目最好的文档。代码是写给人看的，只是顺便让机器运行。

package/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [4.1.2] - 2026-02-07
+
+### 🔧 Adapt Compiler Migration Reliability Fixes
+
+v4.1.2 fixes regressions in multi-platform `adapt` output generation and adds regression coverage to prevent command/skill migration gaps.
+
+#### Fixed
+
+- **Nested command compilation restored**
+  - `adapt` now recursively scans `.claude/commands/**` instead of top-level only
+  - Preserves relative command paths (for example `flow/new` → platform subdirectories)
+  - Ensures command outputs are emitted to matching platform folder structures
+
+- **Skills migration completeness restored**
+  - Added recursive Skill discovery for grouped and root-level skills
+  - Registry and platform emitters now discover the same full skill set
+  - Resolved missing Codex/Cursor/Qwen/Antigravity skill outputs
+
+- **Module emission restored in main compile path**
+  - `adapt` main flow now emits skills/agents/rules/hooks in addition to commands
+  - CLI output now reports module-level emission statistics for easier verification
+
+- **Resource copy reliability improved**
+  - Handles Skill resource symlinks more robustly during emitter copy
+  - Ignores glob-style inline paths to avoid false missing-file warnings
+  - Fixed broken workflow skill symlink targets under `.claude/skills/workflow/*`
+
+#### Added
+
+- **Regression tests for adapt migration pipeline**
+  - Parser recursive command discovery tests
+  - Skill discovery tests (grouped + root-level)
+  - Compile end-to-end regression test
+  - Resource copier glob-filter test
+
+#### Benefits
+
+- ✅ `cc-devflow adapt --platform <target>` now generates complete expected outputs
+- ✅ Cross-platform command/skill migration behavior is consistent and test-protected
+- ✅ Release/debug verification is faster with explicit module emission metrics
+
 ## [4.1.1] - 2026-02-07
 
 ### 🔧 Flow-Init Script Reliability + Flow Docs Alignment

package/bin/adapt.js

@@ -215,6 +215,10 @@ async function main() {
       console.log(`  Files skipped: ${result.filesSkipped}`);
       console.log(`  Resources copied: ${result.resourcesCopied}`);
       console.log(`  Resources skipped: ${result.resourcesSkipped}`);
+      console.log(`  Skills emitted: ${result.skillsEmitted}`);
+      console.log(`  Agents emitted: ${result.agentsEmitted}`);
+      console.log(`  Module rules emitted: ${result.moduleRulesEmitted}`);
+      console.log(`  Hooks emitted: ${result.hooksEmitted}`);
       console.log(`  Skills registered: ${result.skillsRegistered}`);
       console.log(`  Rules generated: ${result.rulesGenerated}`);
       process.exit(0);

package/lib/compiler/CLAUDE.md

@@ -13,6 +13,8 @@ lib/compiler/
 ├── schemas.js          # Zod validation schemas (CommandIR, Manifest)
 ├── errors.js           # Custom error types (MissingFrontmatter, UnknownAlias, etc.)
 ├── skills-registry.js  # Generate skills registry from .claude/skills/
+├── skill-discovery.js  # Recursive SKILL.md discovery (grouped + root skills)
+├── resource-copier.js  # Resource collection/copy and .claude path rewriting
 ├── platforms.js        # Platform configuration registry (v2.0)
 ├── context-expander.js # context.jsonl expansion (v3.0)
 ├── index.js            # Compiler entry point, orchestrates pipeline
@@ -69,7 +71,7 @@ Platform-specific output directories
 ## CLI Usage
 
 ```bash
-# Legacy: Compile commands only
+# Compile commands + modules
 npm run adapt                       # Compile all platforms
 npm run adapt -- --platform codex   # Compile single platform
 npm run adapt -- --check            # Drift detection only
@@ -81,8 +83,8 @@ npm run adapt -- --modules skills --platform cursor
 
 ## Key APIs
 
-### compile(options) - Legacy
-Compiles commands only (backward compatible).
+### compile(options) - Main Flow
+Compiles commands and emits platform modules (skills, agents, rules, hooks).
 
 ### compileMultiModule(options) - v3.0
 Compiles all specified modules.

package/lib/compiler/__tests__/compile-regression.test.js

@@ -0,0 +1,94 @@
+/**
+ * T043: Compile Regression Tests
+ *
+ * [INPUT]: 临时 .claude 项目
+ * [OUTPUT]: compile() 端到端回归验证
+ * [POS]: 修复 adapt 回归，确保命令与技能正确落盘
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { compile } = require('../index.js');
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+function setupProjectFixture(rootDir) {
+  writeFile(path.join(rootDir, '.claude/commands/flow/new.md'), `---
+name: flow-new
+description: Create new requirement
+---
+# Flow New
+
+Run flow new
+`);
+
+  writeFile(path.join(rootDir, '.claude/skills/workflow/flow-dev/SKILL.md'), `---
+name: flow-dev
+description: Workflow dev skill
+---
+# flow-dev
+`);
+
+  writeFile(path.join(rootDir, '.claude/skills/orchestrator/SKILL.md'), `---
+name: orchestrator
+description: Root level skill
+---
+# orchestrator
+`);
+
+  writeFile(path.join(rootDir, '.claude/agents/planner.md'), `---
+name: planner
+description: Plan tasks
+---
+# planner
+`);
+
+  writeFile(path.join(rootDir, '.claude/rules/base-rule.md'), `---
+description: Base rule
+alwaysApply: true
+---
+# rule
+`);
+}
+
+describe('compile() regression', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'compile-regression-'));
+    setupProjectFixture(tempDir);
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test('should compile nested commands and emit skills for codex', async () => {
+    const result = await compile({
+      sourceDir: '.claude/commands',
+      skillsDir: '.claude/skills',
+      outputBaseDir: '.',
+      platforms: ['codex'],
+      verbose: false
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.filesCompiled).toBe(1);
+    expect(result.skillsRegistered).toBe(2);
+    expect(result.skillsEmitted).toBe(2);
+    expect(fs.existsSync('.codex/prompts/flow/new.md')).toBe(true);
+    expect(fs.existsSync('.codex/skills/flow-dev/SKILL.md')).toBe(true);
+    expect(fs.existsSync('.codex/skills/orchestrator/SKILL.md')).toBe(true);
+    expect(fs.existsSync('AGENTS.md')).toBe(true);
+  });
+});

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

@@ -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);
       }

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

@@ -70,9 +70,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 });

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

@@ -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);
       }

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

@@ -21,6 +21,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 CursorEmitter extends BaseEmitter {
   get name() {
@@ -58,40 +59,19 @@ class CursorEmitter 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._emitSkillAsRule(
-            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._emitSkillAsRule(
+          skill.name,
+          skill.skillDir,
+          skill.skillMdPath,
+          targetDir
+        );
+        results.push(result);
+      } catch (error) {
+        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
       }
     }
 

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

@@ -20,6 +20,7 @@ const toml = require('@iarna/toml');
 const matter = require('gray-matter');
 const BaseEmitter = require('./base-emitter.js');
 const { ContextExpander } = require('../context-expander.js');
+const { discoverSkillEntries } = require('../skill-discovery.js');
 
 class QwenEmitter extends BaseEmitter {
   get name() {
@@ -63,40 +64,19 @@ class QwenEmitter 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._emitSkillAsToml(
-            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._emitSkillAsToml(
+          skill.name,
+          skill.skillDir,
+          skill.skillMdPath,
+          targetDir
+        );
+        results.push(result);
+      } catch (error) {
+        console.warn(`Warning: Failed to emit skill ${skill.name}: ${error.message}`);
       }
     }
 

package/lib/compiler/index.js

@@ -230,6 +230,110 @@ function getRulesTargetPath(platform, config) {
   return path.join(config.folder, rulesConfig.dir || 'rules');
 }
 
+function getHooksTargetDir(config) {
+  return config.folder;
+}
+
+// ============================================================
+// emitPlatformModules - 编译 Skills/Agents/Rules/Hooks 模块
+// ============================================================
+async function emitPlatformModules(sourceBaseDir, platforms, options = {}) {
+  const {
+    includeSkills = true,
+    includeAgents = true,
+    includeRules = true,
+    includeHooks = true,
+    verbose = false
+  } = options;
+
+  const summary = {
+    skillsEmitted: 0,
+    agentsEmitted: 0,
+    moduleRulesEmitted: 0,
+    hooksEmitted: 0,
+    errors: []
+  };
+
+  for (const platform of platforms) {
+    const emitter = getEmitter(platform);
+    const platformConfig = getPlatformConfig(platform);
+
+    if (includeSkills) {
+      try {
+        const skillsSourceDir = path.join(sourceBaseDir, 'skills');
+        const skillsTargetDir = getSkillsTargetDir(platform, platformConfig);
+
+        if (fs.existsSync(skillsSourceDir)) {
+          const skillResults = await emitter.emitSkills(skillsSourceDir, skillsTargetDir);
+          summary.skillsEmitted += skillResults.length;
+
+          if (verbose && skillResults.length > 0) {
+            console.log(`Emitted skills: ${platform} (${skillResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/skills: ${error.message}`);
+      }
+    }
+
+    if (includeAgents) {
+      try {
+        const agentsSourceDir = path.join(sourceBaseDir, 'agents');
+        const agentsTargetPath = getAgentsTargetPath(platform, platformConfig);
+
+        if (fs.existsSync(agentsSourceDir)) {
+          const agentResults = await emitter.emitAgents(agentsSourceDir, agentsTargetPath);
+          summary.agentsEmitted += agentResults.length;
+
+          if (verbose && agentResults.length > 0) {
+            console.log(`Emitted agents: ${platform} (${agentResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/agents: ${error.message}`);
+      }
+    }
+
+    if (includeRules) {
+      try {
+        const rulesSourceDir = path.join(sourceBaseDir, 'rules');
+        const rulesTargetPath = getRulesTargetPath(platform, platformConfig);
+
+        if (fs.existsSync(rulesSourceDir)) {
+          const ruleResults = await emitter.emitRules(rulesSourceDir, rulesTargetPath);
+          summary.moduleRulesEmitted += ruleResults.length;
+
+          if (verbose && ruleResults.length > 0) {
+            console.log(`Emitted module rules: ${platform} (${ruleResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/rules: ${error.message}`);
+      }
+    }
+
+    if (includeHooks && isModuleSupported(platform, 'hooks')) {
+      try {
+        const hooksSourceDir = path.join(sourceBaseDir, 'hooks');
+        const hooksTargetDir = getHooksTargetDir(platformConfig);
+
+        if (fs.existsSync(hooksSourceDir)) {
+          const hookResults = await emitter.emitHooks(hooksSourceDir, hooksTargetDir);
+          summary.hooksEmitted += hookResults.length;
+
+          if (verbose && hookResults.length > 0) {
+            console.log(`Emitted hooks: ${platform} (${hookResults.length})`);
+          }
+        }
+      } catch (error) {
+        summary.errors.push(`${platform}/hooks: ${error.message}`);
+      }
+    }
+  }
+
+  return summary;
+}
+
 // ============================================================
 // compile - 编译主函数
 // ============================================================
@@ -259,6 +363,10 @@ async function compile(options = {}) {
     filesSkipped: 0,
     resourcesCopied: 0,
     resourcesSkipped: 0,
+    skillsEmitted: 0,
+    agentsEmitted: 0,
+    moduleRulesEmitted: 0,
+    hooksEmitted: 0,
     rulesGenerated: 0,
     skillsRegistered: 0,
     errors: []
@@ -307,6 +415,21 @@ async function compile(options = {}) {
     }
   }
 
+  // 编译多模块产物（skills / agents / rules / hooks）
+  const sourceBaseDir = path.resolve(path.dirname(sourceDir));
+  const moduleSummary = await emitPlatformModules(sourceBaseDir, platforms, {
+    includeSkills: skills,
+    includeAgents: true,
+    includeRules: rules,
+    includeHooks: true,
+    verbose
+  });
+  result.skillsEmitted = moduleSummary.skillsEmitted;
+  result.agentsEmitted = moduleSummary.agentsEmitted;
+  result.moduleRulesEmitted = moduleSummary.moduleRulesEmitted;
+  result.hooksEmitted = moduleSummary.hooksEmitted;
+  result.errors.push(...moduleSummary.errors);
+
   // 解析所有命令文件
   const absoluteSourceDir = path.resolve(sourceDir);
   let irs = [];
@@ -440,6 +563,7 @@ async function compile(options = {}) {
   manifest.generatedAt = new Date().toISOString();
   await saveManifest(manifest, manifestPath);
 
+  result.success = result.errors.length === 0;
   return result;
 }
 

package/lib/compiler/parser.js

@@ -225,18 +225,18 @@ function parseCommand(filePath) {
 async function parseAllCommands(dirPath) {
   const absoluteDir = path.resolve(dirPath);
 
-  // 读取目录中的所有文件
-  const files = fs.readdirSync(absoluteDir);
+  const mdFiles = collectMarkdownFiles(absoluteDir, absoluteDir);
 
-  // 过滤 .md 文件
-  const mdFiles = files.filter(file => file.endsWith('.md'));
-
-  // 解析每个文件
+  // 解析每个文件（保留相对路径，支持分层输出）
   const results = [];
-  for (const file of mdFiles) {
-    const filePath = path.join(absoluteDir, file);
+  for (const filePath of mdFiles) {
     try {
       const ir = parseCommand(filePath);
+
+      // 输出文件名使用 commands 根目录相对路径（不含扩展名）
+      const relativePath = path.relative(absoluteDir, filePath).replace(/\\/g, '/');
+      ir.source.filename = relativePath.replace(/\.md$/i, '');
+
       results.push(ir);
     } catch (error) {
       // 重新抛出以便调用者处理
@@ -247,9 +247,44 @@ async function parseAllCommands(dirPath) {
   return results;
 }
 
+// ============================================================
+// collectMarkdownFiles - 递归收集 Markdown 文件
+// ============================================================
+function collectMarkdownFiles(rootDir, currentDir) {
+  const results = [];
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    // 跳过隐藏目录与 "_" 前缀目录
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith('.') || entry.name.startsWith('_')) {
+        continue;
+      }
+
+      const childFiles = collectMarkdownFiles(rootDir, path.join(currentDir, entry.name));
+      results.push(...childFiles);
+      continue;
+    }
+
+    if (!entry.isFile() || !entry.name.endsWith('.md')) {
+      continue;
+    }
+
+    results.push(path.join(currentDir, entry.name));
+  }
+
+  // 统一排序，确保输出稳定
+  if (currentDir === rootDir) {
+    results.sort((a, b) => a.localeCompare(b));
+  }
+
+  return results;
+}
+
 module.exports = {
   parseCommand,
   parseAllCommands,
+  collectMarkdownFiles,
   hashContent,
   detectPlaceholders,
   validateScriptAliases,

package/lib/compiler/resource-copier.js

@@ -120,6 +120,12 @@ function scanInlineClaudePaths(content) {
     let cleanPath = match[0];
     // 移除末尾的常见标点
     cleanPath = cleanPath.replace(/[,;:.\s]+$/, '');
+
+    // 跳过 glob 模式（例如 *.jsonl.template），避免误判为单文件资源
+    if (cleanPath.includes('*')) {
+      continue;
+    }
+
     paths.add(cleanPath);
   }
 

package/lib/compiler/skill-discovery.js

@@ -0,0 +1,68 @@
+/**
+ * T041: Skill Discovery Utility
+ *
+ * [INPUT]: .claude/skills/ 目录
+ * [OUTPUT]: SkillEntry[] (name, skillDir, skillMdPath)
+ * [POS]: Skills 扫描工具，统一发现分组与非分组 Skill
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ *
+ * 规则:
+ * - 递归扫描所有子目录
+ * - 目录内存在 SKILL.md 即判定为 Skill
+ * - 跳过以下划线开头的目录（例如 _reference-implementations）
+ * - 扫描结果按 skillMdPath 排序，保证输出稳定
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================
+// discoverSkillEntries - 递归扫描 Skill 目录
+// ============================================================
+function discoverSkillEntries(skillsDir) {
+  const absoluteDir = path.resolve(skillsDir);
+
+  if (!fs.existsSync(absoluteDir)) {
+    return [];
+  }
+
+  const entries = [];
+  walkSkillDirs(absoluteDir, entries);
+
+  // 保证输出稳定，避免不同文件系统顺序差异
+  entries.sort((a, b) => a.skillMdPath.localeCompare(b.skillMdPath));
+  return entries;
+}
+
+// ============================================================
+// walkSkillDirs - 深度优先扫描
+// ============================================================
+function walkSkillDirs(dirPath, entries) {
+  const dirName = path.basename(dirPath);
+  if (dirName.startsWith('_')) {
+    return;
+  }
+
+  const skillMdPath = path.join(dirPath, 'SKILL.md');
+  if (fs.existsSync(skillMdPath)) {
+    entries.push({
+      name: dirName,
+      skillDir: dirPath,
+      skillMdPath
+    });
+    return;
+  }
+
+  const children = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const child of children) {
+    if (!child.isDirectory()) {
+      continue;
+    }
+
+    walkSkillDirs(path.join(dirPath, child.name), entries);
+  }
+}
+
+module.exports = {
+  discoverSkillEntries
+};

package/lib/compiler/skills-registry.js

@@ -11,6 +11,7 @@
 const fs = require('fs');
 const path = require('path');
 const matter = require('gray-matter');
+const { discoverSkillEntries } = require('./skill-discovery.js');
 
 // ============================================================
 // Constants
@@ -23,35 +24,18 @@ const REGISTRY_OUTPUT_PATH = 'devflow/.generated/skills-registry.json';
 // ============================================================
 function generateSkillsRegistry(skillsDir) {
   const registry = [];
-  const absoluteDir = path.resolve(skillsDir);
-
-  if (!fs.existsSync(absoluteDir)) {
-    return registry;
-  }
-
-  const entries = fs.readdirSync(absoluteDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith('_')) {
-      continue;
-    }
-
-    const skillDir = path.join(absoluteDir, entry.name);
-    const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-    if (!fs.existsSync(skillMdPath)) {
-      continue;
-    }
+  const skillEntries = discoverSkillEntries(skillsDir);
 
+  for (const entry of skillEntries) {
     try {
-      const skillMdContent = fs.readFileSync(skillMdPath, 'utf8');
+      const skillMdContent = fs.readFileSync(entry.skillMdPath, 'utf8');
       const parsed = matter(skillMdContent);
 
       registry.push({
         name: parsed.data.name || entry.name,
         description: parsed.data.description || '',
         type: parsed.data.type || 'utility',
-        path: skillDir,
+        path: entry.skillDir,
         triggers: []
       });
     } catch (error) {
@@ -82,29 +66,12 @@ async function generateSkillsRegistryV2(skillsDir) {
     }
   }
 
-  // 扫描技能目录
-  if (!fs.existsSync(absoluteDir)) {
-    return createRegistry(skills);
-  }
-
-  const entries = fs.readdirSync(absoluteDir, { withFileTypes: true });
+  // 扫描技能目录（支持分组与非分组结构）
+  const entries = discoverSkillEntries(absoluteDir);
 
   for (const entry of entries) {
-    // 跳过非目录和 _ 前缀目录
-    if (!entry.isDirectory() || entry.name.startsWith('_')) {
-      continue;
-    }
-
-    const skillDir = path.join(absoluteDir, entry.name);
-    const skillMdPath = path.join(skillDir, 'SKILL.md');
-
-    // 必须有 SKILL.md
-    if (!fs.existsSync(skillMdPath)) {
-      continue;
-    }
-
     try {
-      const skillEntry = parseSkillEntry(entry.name, skillDir, skillMdPath, skillRules);
+      const skillEntry = parseSkillEntry(entry.name, entry.skillDir, entry.skillMdPath, skillRules);
       if (skillEntry) {
         skills.push(skillEntry);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cc-devflow",
-    "version": "4.1.1",
+    "version": "4.1.2",
     "description": "DevFlow CLI tool",
     "main": "bin/cc-devflow.js",
     "bin": {