cc-devflow 4.3.0 → 4.4.1

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

@@ -1,15 +1,11 @@
 /**
  * T011: Parser Tests
- * Tests for parsing .claude/commands/*.md files
- * Expected: All tests FAIL (parser not implemented)
+ * Tests for parsing optional prompt markdown files
  */
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
 
-// ============================================================
-// Parser imports - will fail until lib/compiler/parser.js exists
-// ============================================================
 let parser;
 let errors;
 try {
@@ -49,20 +45,20 @@ describe('Parser Module', () => {
   describe('AC1: Parse YAML frontmatter', () => {
     it('should parse file with valid frontmatter and return IR', () => {
       const content = `---
-name: flow-prd
-description: Generate PRD document
+name: cc-plan
+description: Plan one requirement
 scripts:
   prereq: .claude/scripts/check-prerequisites.sh
 ---
-# Flow PRD Command
+# CC-Plan Prompt
 
 Run {SCRIPT:prereq}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
-        expect(ir.frontmatter.name).toBe('flow-prd');
-        expect(ir.frontmatter.description).toBe('Generate PRD document');
+        const ir = parser.parsePromptFile(tmpFile);
+        expect(ir.frontmatter.name).toBe('cc-plan');
+        expect(ir.frontmatter.description).toBe('Plan one requirement');
         expect(ir.frontmatter.scripts).toBeDefined();
         expect(ir.frontmatter.scripts.prereq).toBe('.claude/scripts/check-prerequisites.sh');
       } finally {
@@ -81,7 +77,7 @@ Body content here
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.body).toContain('# Test Command');
         expect(ir.body).toContain('Body content here');
         expect(ir.body).not.toContain('---');
@@ -98,7 +94,7 @@ Body content here
   describe('AC2: Parse scripts alias-path mapping', () => {
     it('should parse multiple scripts aliases', () => {
       const content = `---
-name: flow-test
+name: cc-check
 description: Test
 scripts:
   prereq: .claude/scripts/prereq.sh
@@ -109,7 +105,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(Object.keys(ir.frontmatter.scripts)).toHaveLength(3);
         expect(ir.frontmatter.scripts.prereq).toBe('.claude/scripts/prereq.sh');
         expect(ir.frontmatter.scripts.validate).toBe('.claude/scripts/validate.sh');
@@ -128,7 +124,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.frontmatter.scripts).toBeUndefined();
       } finally {
         cleanup(tmpFile);
@@ -151,7 +147,7 @@ Run {SCRIPT:prereq}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const scriptPlaceholders = ir.placeholders.filter(p => p.type === 'SCRIPT');
         expect(scriptPlaceholders).toHaveLength(1);
         expect(scriptPlaceholders[0].alias).toBe('prereq');
@@ -173,7 +169,7 @@ Run {SCRIPT:first} then {SCRIPT:second}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const scriptPlaceholders = ir.placeholders.filter(p => p.type === 'SCRIPT');
         expect(scriptPlaceholders).toHaveLength(2);
         expect(scriptPlaceholders.map(p => p.alias).sort()).toEqual(['first', 'second']);
@@ -193,7 +189,7 @@ Execute {AGENT_SCRIPT}
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const agentPlaceholders = ir.placeholders.filter(p => p.type === 'AGENT_SCRIPT');
         expect(agentPlaceholders).toHaveLength(1);
         expect(agentPlaceholders[0].raw).toBe('{AGENT_SCRIPT}');
@@ -211,7 +207,7 @@ Input: $ARGUMENTS
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const argPlaceholders = ir.placeholders.filter(p => p.type === 'ARGUMENTS');
         expect(argPlaceholders).toHaveLength(1);
         expect(argPlaceholders[0].raw).toBe('$ARGUMENTS');
@@ -231,7 +227,7 @@ Start {SCRIPT:x} end
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         const placeholder = ir.placeholders.find(p => p.type === 'SCRIPT');
         expect(placeholder.position).toBeDefined();
         expect(typeof placeholder.position.start).toBe('number');
@@ -254,7 +250,7 @@ Just markdown content
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.MissingFrontmatterError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.MissingFrontmatterError);
       } finally {
         cleanup(tmpFile);
       }
@@ -263,7 +259,7 @@ Just markdown content
     it('should throw MissingFrontmatterError for empty file', () => {
       const tmpFile = createTempFile('');
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.MissingFrontmatterError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.MissingFrontmatterError);
       } finally {
         cleanup(tmpFile);
       }
@@ -277,7 +273,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.InvalidFrontmatterError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.InvalidFrontmatterError);
       } finally {
         cleanup(tmpFile);
       }
@@ -299,7 +295,7 @@ Run {SCRIPT:unknown}
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.UnknownAliasError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.UnknownAliasError);
       } finally {
         cleanup(tmpFile);
       }
@@ -314,7 +310,7 @@ Run {SCRIPT:prereq}
 `;
       const tmpFile = createTempFile(content);
       try {
-        expect(() => parser.parseCommand(tmpFile)).toThrow(errors.UnknownAliasError);
+        expect(() => parser.parsePromptFile(tmpFile)).toThrow(errors.UnknownAliasError);
       } finally {
         cleanup(tmpFile);
       }
@@ -322,10 +318,10 @@ Run {SCRIPT:prereq}
   });
 
   // ----------------------------------------------------------
-  // parseCommand() specific tests
+  // parsePromptFile() specific tests
   // ----------------------------------------------------------
-  describe('parseCommand()', () => {
-    it('should return valid CommandIR structure', () => {
+  describe('parsePromptFile()', () => {
+    it('should return valid PromptIR structure', () => {
       const content = `---
 name: valid
 description: Valid command
@@ -334,7 +330,7 @@ Content
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir).toHaveProperty('source');
         expect(ir).toHaveProperty('frontmatter');
         expect(ir).toHaveProperty('body');
@@ -356,7 +352,7 @@ Content
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.source.hash).toMatch(/^[a-f0-9]{64}$/);
       } finally {
         cleanup(tmpFile);
@@ -372,7 +368,7 @@ Body
 `;
       const tmpFile = createTempFile(content);
       try {
-        const ir = parser.parseCommand(tmpFile);
+        const ir = parser.parsePromptFile(tmpFile);
         expect(ir.source.filename).not.toContain('.md');
       } finally {
         cleanup(tmpFile);
@@ -381,10 +377,10 @@ Body
   });
 
   // ----------------------------------------------------------
-  // parseAllCommands() tests
+  // parseAllPromptFiles() tests
   // ----------------------------------------------------------
-  describe('parseAllCommands()', () => {
-    it('should return array of CommandIR', async () => {
+  describe('parseAllPromptFiles()', () => {
+    it('should return array of PromptIR', async () => {
       // 使用临时目录测试，避免依赖真实代码库状态
       const tmpDir = path.join(os.tmpdir(), `test-array-${Date.now()}`);
       fs.mkdirSync(tmpDir, { recursive: true });
@@ -394,7 +390,7 @@ description: Test command
 ---
 Body`);
       try {
-        const result = await parser.parseAllCommands(tmpDir);
+        const result = await parser.parseAllPromptFiles(tmpDir);
         expect(Array.isArray(result)).toBe(true);
       } finally {
         fs.rmSync(tmpDir, { recursive: true, force: true });
@@ -415,7 +411,7 @@ description: Command 2
 ---
 Body 2`);
       try {
-        const result = await parser.parseAllCommands(tmpDir);
+        const result = await parser.parseAllPromptFiles(tmpDir);
         expect(result.length).toBe(2);
         result.forEach(ir => {
           expect(ir).toHaveProperty('source');
@@ -443,7 +439,7 @@ Body`);
       fs.writeFileSync(txtFile, 'not markdown');
 
       try {
-        const result = await parser.parseAllCommands(tmpDir);
+        const result = await parser.parseAllPromptFiles(tmpDir);
         expect(result).toHaveLength(1);
         expect(result[0].source.filename).toBe('test');
       } finally {
@@ -452,72 +448,5 @@ 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 ignore CLAUDE.md documentation files', async () => {
-      const tmpDir = path.join(os.tmpdir(), `test-claude-doc-${Date.now()}`);
-      const flowDir = path.join(tmpDir, 'flow');
-      fs.mkdirSync(flowDir, { recursive: true });
-
-      fs.writeFileSync(path.join(flowDir, 'CLAUDE.md'), '# flow docs only');
-      fs.writeFileSync(path.join(flowDir, 'init.md'), `---
-name: flow-init
-description: Flow init command
----
-Body`);
-
-      try {
-        const result = await parser.parseAllCommands(tmpDir);
-        expect(result).toHaveLength(1);
-        expect(result[0].source.filename).toBe('flow/init');
-      } 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__/schemas.test.js

@@ -1,13 +1,9 @@
 /**
  * T009: Zod Schemas Tests
- * Tests for CommandIR, Frontmatter, Manifest schemas
- * Expected: All tests FAIL (schemas not implemented)
+ * Tests for PromptIR, Frontmatter, and Manifest schemas
  */
 const { z } = require('zod');
 
-// ============================================================
-// Schema imports - will fail until lib/compiler/schemas.js exists
-// ============================================================
 let schemas;
 try {
   schemas = require('../schemas.js');
@@ -78,16 +74,16 @@ describe('Zod Schemas', () => {
   describe('FrontmatterSchema', () => {
     it('should validate minimal frontmatter (name + description)', () => {
       const valid = {
-        name: 'flow-prd',
-        description: 'Generate PRD document'
+        name: 'cc-plan',
+        description: 'Plan one requirement'
       };
       expect(() => schemas.FrontmatterSchema.parse(valid)).not.toThrow();
     });
 
     it('should validate frontmatter with scripts', () => {
       const valid = {
-        name: 'flow-prd',
-        description: 'Generate PRD document',
+        name: 'cc-plan',
+        description: 'Plan one requirement',
         scripts: {
           prereq: '.claude/scripts/check-prerequisites.sh',
           validate: '.claude/scripts/validate.sh'
@@ -98,8 +94,8 @@ describe('Zod Schemas', () => {
 
     it('should validate frontmatter with agent_scripts', () => {
       const valid = {
-        name: 'flow-init',
-        description: 'Initialize requirement',
+        name: 'cc-check',
+        description: 'Verify with evidence',
         agent_scripts: {
           sh: 'echo "shell script"',
           ps: 'Write-Host "powershell"'
@@ -117,7 +113,7 @@ describe('Zod Schemas', () => {
 
     it('should reject missing description', () => {
       const invalid = {
-        name: 'flow-test'
+        name: 'cc-do'
       };
       expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
     });
@@ -132,7 +128,7 @@ describe('Zod Schemas', () => {
 
     it('should reject empty description', () => {
       const invalid = {
-        name: 'flow-test',
+        name: 'cc-do',
         description: ''
       };
       expect(() => schemas.FrontmatterSchema.parse(invalid)).toThrow();
@@ -140,36 +136,36 @@ describe('Zod Schemas', () => {
   });
 
   // ----------------------------------------------------------
-  // CommandIRSchema Tests
+  // PromptIRSchema Tests
   // ----------------------------------------------------------
-  describe('CommandIRSchema', () => {
-    it('should validate complete CommandIR', () => {
+  describe('PromptIRSchema', () => {
+    it('should validate complete PromptIR', () => {
       const valid = {
         source: {
-          path: '/path/to/flow-prd.md',
-          filename: 'flow-prd',
+          path: '/path/to/cc-plan.md',
+          filename: 'cc-plan',
           hash: 'sha256:abc123def456'
         },
         frontmatter: {
-          name: 'flow-prd',
-          description: 'Generate PRD'
+          name: 'cc-plan',
+          description: 'Plan one requirement'
         },
-        body: '# Flow PRD\n\nContent here...',
+        body: '# CC-Plan\n\nContent here...',
         placeholders: []
       };
-      expect(() => schemas.CommandIRSchema.parse(valid)).not.toThrow();
+      expect(() => schemas.PromptIRSchema.parse(valid)).not.toThrow();
     });
 
-    it('should validate CommandIR with placeholders', () => {
+    it('should validate PromptIR with placeholders', () => {
       const valid = {
         source: {
-          path: '/path/to/flow-prd.md',
-          filename: 'flow-prd',
+          path: '/path/to/cc-plan.md',
+          filename: 'cc-plan',
           hash: 'sha256:abc123'
         },
         frontmatter: {
-          name: 'flow-prd',
-          description: 'Generate PRD',
+          name: 'cc-plan',
+          description: 'Plan one requirement',
           scripts: { prereq: '.claude/scripts/prereq.sh' }
         },
         body: 'Run {SCRIPT:prereq}',
@@ -180,7 +176,7 @@ describe('Zod Schemas', () => {
           position: { start: 4, end: 19 }
         }]
       };
-      expect(() => schemas.CommandIRSchema.parse(valid)).not.toThrow();
+      expect(() => schemas.PromptIRSchema.parse(valid)).not.toThrow();
     });
 
     it('should reject missing source', () => {
@@ -189,7 +185,7 @@ describe('Zod Schemas', () => {
         body: 'test',
         placeholders: []
       };
-      expect(() => schemas.CommandIRSchema.parse(invalid)).toThrow();
+      expect(() => schemas.PromptIRSchema.parse(invalid)).toThrow();
     });
 
     it('should reject missing body', () => {
@@ -198,7 +194,7 @@ describe('Zod Schemas', () => {
         frontmatter: { name: 'test', description: 'test' },
         placeholders: []
       };
-      expect(() => schemas.CommandIRSchema.parse(invalid)).toThrow();
+      expect(() => schemas.PromptIRSchema.parse(invalid)).toThrow();
     });
   });
 
@@ -208,8 +204,8 @@ describe('Zod Schemas', () => {
   describe('ManifestEntrySchema', () => {
     it('should validate valid manifest entry', () => {
       const valid = {
-        source: '.claude/commands/flow-prd.md',
-        target: '.codex/prompts/flow-prd.md',
+        source: '.claude/commands/cc-plan.md',
+        target: '.codex/prompts/cc-plan.md',
         hash: 'sha256:abc123',
         timestamp: '2025-12-18T10:00:00Z',
         platform: 'codex'
@@ -263,8 +259,8 @@ describe('Zod Schemas', () => {
         version: '1.0.0',
         generatedAt: '2025-12-18T10:00:00Z',
         entries: [{
-          source: '.claude/commands/flow-prd.md',
-          target: '.codex/prompts/flow-prd.md',
+          source: '.claude/commands/cc-plan.md',
+          target: '.codex/prompts/cc-plan.md',
           hash: 'sha256:abc',
           timestamp: '2025-12-18T10:00:00Z',
           platform: 'codex'

package/lib/compiler/__tests__/skills-registry.test.js

@@ -45,6 +45,14 @@ describe('Skills Registry Generator', () => {
         expect(skill).toHaveProperty('type');
         expect(skill).toHaveProperty('skillPath');
         expect(skill).toHaveProperty('triggers');
+        expect(skill).toHaveProperty('reads');
+        expect(skill).toHaveProperty('writes');
+        expect(skill).toHaveProperty('effects');
+        expect(skill).toHaveProperty('entryGate');
+        expect(skill).toHaveProperty('exitCriteria');
+        expect(skill).toHaveProperty('reroutes');
+        expect(skill).toHaveProperty('recoveryModes');
+        expect(skill).toHaveProperty('toolBudget');
       }
     });
 
@@ -87,6 +95,22 @@ describe('Skills Registry Generator', () => {
 
         // skillPath: string (required)
         expect(typeof skill.skillPath).toBe('string');
+
+        // contract fields
+        expect(Array.isArray(skill.reads)).toBe(true);
+        expect(Array.isArray(skill.writes)).toBe(true);
+        for (const write of skill.writes) {
+          expect(typeof write.path).toBe('string');
+          expect(write.path.length).toBeGreaterThan(0);
+          expect(typeof write.durability).toBe('string');
+          expect(typeof write.required).toBe('boolean');
+        }
+        expect(Array.isArray(skill.effects)).toBe(true);
+        expect(Array.isArray(skill.entryGate)).toBe(true);
+        expect(Array.isArray(skill.exitCriteria)).toBe(true);
+        expect(Array.isArray(skill.reroutes)).toBe(true);
+        expect(Array.isArray(skill.recoveryModes)).toBe(true);
+        expect(typeof skill.toolBudget).toBe('object');
       }
     });
 
@@ -103,6 +127,96 @@ describe('Skills Registry Generator', () => {
       const uniqueNames = [...new Set(names)];
       expect(names.length).toBe(uniqueNames.length);
     });
+
+    test('should parse skills without frontmatter warnings', async () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      await generateSkillsRegistryV2('.claude/skills');
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
+
+    test('should resolve bundled reads relative to the skill directory', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const investigate = result.skills.find((skill) => skill.name === 'cc-investigate');
+
+      expect(investigate).toBeDefined();
+      expect(investigate.reads).toContain('.claude/skills/cc-investigate/references/investigation-contract.md');
+      expect(investigate.reads).not.toContain('references/investigation-contract.md');
+    });
+
+    test('should separate concrete writes from conceptual effects', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const execute = result.skills.find((skill) => skill.name === 'cc-do');
+
+      expect(execute).toBeDefined();
+      expect(execute.writes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            path: 'devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json',
+            durability: 'durable',
+            required: true
+          })
+        ])
+      );
+      expect(execute.writes).not.toEqual(
+        expect.arrayContaining([expect.objectContaining({ path: 'code changes' })])
+      );
+      expect(execute.effects).toContain('code changes');
+      expect(execute.effects).toContain('test changes');
+    });
+
+    test('should preserve conditional and exclusive write metadata', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const act = result.skills.find((skill) => skill.name === 'cc-act');
+
+      expect(act).toBeDefined();
+      expect(act.writes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            path: 'devflow/changes/<change-key>/handoff/pr-brief.md',
+            required: false,
+            exclusiveGroup: 'handoff'
+          }),
+          expect.objectContaining({
+            path: 'devflow/changes/<change-key>/handoff/release-note.md',
+            required: false,
+            exclusiveGroup: 'handoff'
+          })
+        ])
+      );
+    });
+
+    test('should publish roadmap outputs under devflow', async () => {
+      const { generateSkillsRegistryV2 } = require('../skills-registry');
+
+      const result = await generateSkillsRegistryV2('.claude/skills');
+      const roadmap = result.skills.find((skill) => skill.name === 'cc-roadmap');
+
+      expect(roadmap).toBeDefined();
+      expect(roadmap.writes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ path: 'devflow/ROADMAP.md' }),
+          expect.objectContaining({ path: 'devflow/BACKLOG.md' })
+        ])
+      );
+      expect(roadmap.writes).not.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ path: 'ROADMAP.md' }),
+          expect.objectContaining({ path: 'BACKLOG.md' }),
+          expect.objectContaining({ path: 'devflow/roadmap/roadmap.md' }),
+          expect.objectContaining({ path: 'devflow/roadmap/backlog.md' })
+        ])
+      );
+    });
   });
 
   describe('writeSkillsRegistry()', () => {

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

@@ -1,12 +1,8 @@
 /**
  * T012: Transformer Tests
  * Tests for placeholder expansion and argument mapping
- * Expected: All tests FAIL (transformer not implemented)
  */
 
-// ============================================================
-// Transformer imports - will fail until lib/compiler/transformer.js exists
-// ============================================================
 let transformer;
 let errors;
 try {
@@ -17,15 +13,15 @@ try {
   errors = null;
 }
 
-// Sample CommandIR for testing
+// Sample PromptIR for testing
 const createTestIR = (overrides = {}) => ({
   source: {
-    path: '/test/flow-test.md',
-    filename: 'flow-test',
+    path: '/test/cc-do.md',
+    filename: 'cc-do',
     hash: 'sha256:abc123'
   },
   frontmatter: {
-    name: 'flow-test',
+    name: 'cc-do',
     description: 'Test command',
     scripts: {
       prereq: '.claude/scripts/check-prerequisites.sh',
@@ -193,7 +189,7 @@ describe('Transformer Module', () => {
     it('should preserve frontmatter in result', () => {
       const ir = createTestIR({ body: 'Test', placeholders: [] });
       const result = transformer.transformForPlatform(ir, 'codex');
-      expect(result.frontmatter.name).toBe('flow-test');
+      expect(result.frontmatter.name).toBe('cc-do');
       expect(result.frontmatter.description).toBe('Test command');
     });