cc-devflow 4.3.0 → 4.4.1

package/lib/skill-runtime/__tests__/intent.test.js

@@ -0,0 +1,219 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  syncIntentMemory,
+  syncIntentPrBrief
+} = require('../intent');
+const {
+  getIntentPrBriefPath,
+  getIntentResumeIndexPath,
+  getIntentHandoffArtifactPaths,
+  getLegacyIntentProjectionPaths
+} = require('../artifacts');
+const {
+  getRuntimeStatePath,
+  getTaskManifestPath,
+  getReportCardPath,
+  getCheckpointPath
+} = require('../store');
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeText(filePath, content = 'stale\n') {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+describe('intent handoff bridge', () => {
+  let repoRoot;
+
+  beforeEach(() => {
+    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-intent-'));
+
+    writeJson(
+      getRuntimeStatePath(repoRoot, 'REQ-123'),
+      {
+        changeId: 'REQ-123',
+        changeKey: 'REQ-123-autopilot-memory-bridge',
+        slug: 'autopilot-memory-bridge',
+        createdAt: '2026-03-25T01:00:00.000Z',
+        goal: 'Deliver autopilot memory bridge',
+        status: 'verified',
+        initializedAt: '2026-03-25T01:00:00.000Z',
+        plannedAt: '2026-03-25T01:05:00.000Z',
+        verifiedAt: '2026-03-25T01:10:00.000Z',
+        approval: {
+          status: 'approved',
+          executionMode: 'delegate',
+          planVersion: 1,
+          approvedAt: '2026-03-25T01:06:00.000Z'
+        },
+        updatedAt: '2026-03-25T01:10:00.000Z'
+      }
+    );
+
+    writeJson(
+      getTaskManifestPath(repoRoot, 'REQ-123'),
+      {
+        changeId: 'REQ-123',
+        goal: 'Deliver autopilot memory bridge',
+        createdAt: '2026-03-25T01:05:00.000Z',
+        updatedAt: '2026-03-25T01:10:00.000Z',
+        tasks: [
+          {
+            id: 'T001',
+            title: 'Write intent files',
+            type: 'IMPL',
+            dependsOn: [],
+            touches: ['lib/skill-runtime/intent.js'],
+            run: ['echo ok'],
+            checks: [],
+            status: 'passed',
+            attempts: 1,
+            maxRetries: 1
+          }
+        ],
+        metadata: {
+          source: 'default',
+          generatedBy: 'test',
+          planVersion: 1
+        }
+      }
+    );
+
+    writeJson(
+      getCheckpointPath(repoRoot, 'REQ-123', 'T001'),
+      {
+        changeId: 'REQ-123',
+        taskId: 'T001',
+        sessionId: 'T001-session',
+        planVersion: 1,
+        status: 'passed',
+        summary: 'Task passed after 1 attempt',
+        error: '',
+        outputExcerpt: 'worker-ok',
+        timestamp: '2026-03-25T01:11:00.000Z',
+        attempt: 1
+      }
+    );
+  });
+
+  test('syncIntentMemory removes legacy projection files instead of writing them', async () => {
+    const legacyFiles = getLegacyIntentProjectionPaths(repoRoot, 'REQ-123', ['T001']);
+
+    for (const filePath of legacyFiles) {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, 'legacy\n');
+    }
+
+    await syncIntentMemory(repoRoot, 'REQ-123');
+
+    for (const filePath of legacyFiles) {
+      expect(fs.existsSync(filePath)).toBe(false);
+    }
+    expect(fs.existsSync(getIntentResumeIndexPath(repoRoot, 'REQ-123'))).toBe(false);
+  });
+
+  test('can emit a single local-handoff resume index when explicitly requested', async () => {
+    const resumePath = getIntentResumeIndexPath(repoRoot, 'REQ-123');
+
+    writeJson(
+      getReportCardPath(repoRoot, 'REQ-123'),
+      {
+        changeId: 'REQ-123',
+        overall: 'pass',
+        quickGates: [],
+        strictGates: [],
+        review: { status: 'pass', summary: 'review-ok', details: '', findings: [], taskReviews: {}, diffReview: {} },
+        blockingFindings: [],
+        timestamp: '2026-03-25T01:12:00.000Z'
+      }
+    );
+
+    for (const filePath of getIntentHandoffArtifactPaths(repoRoot, 'REQ-123')) {
+      if (filePath !== resumePath) {
+        writeText(filePath);
+      }
+    }
+
+    await syncIntentMemory(repoRoot, 'REQ-123', { handoff: 'resume' });
+
+    const resumeIndex = fs.readFileSync(resumePath, 'utf8');
+
+    expect(resumeIndex).toContain('Resume Index: REQ-123');
+    expect(resumeIndex).toContain('Durable Truth');
+    for (const filePath of getIntentHandoffArtifactPaths(repoRoot, 'REQ-123')) {
+      expect(fs.existsSync(filePath)).toBe(filePath === resumePath);
+    }
+  });
+
+  test('writes pr brief from manifest, checkpoints, and report-card only', async () => {
+    const prBriefPath = getIntentPrBriefPath(repoRoot, 'REQ-123');
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+    manifest.tasks.push({
+      id: 'T002',
+      title: 'Skip follow-up after dependency gate',
+      type: 'IMPL',
+      dependsOn: ['T001'],
+      touches: ['lib/skill-runtime/operations/autopilot-core.js'],
+      run: ['echo skipped'],
+      checks: [],
+      status: 'skipped',
+      attempts: 0,
+      maxRetries: 1,
+      lastError: 'Blocked by failed dependency'
+    });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+    writeJson(
+      getReportCardPath(repoRoot, 'REQ-123'),
+      {
+        changeId: 'REQ-123',
+        overall: 'pass',
+        quickGates: [
+          { name: 'lint', status: 'pass', command: 'npm run lint', durationMs: 1200, details: '' }
+        ],
+        strictGates: [
+          { name: 'test', status: 'pass', command: 'npm test', durationMs: 2400, details: '' }
+        ],
+        review: {
+          status: 'pass',
+          summary: 'review-ok',
+          details: '',
+          findings: [],
+          taskReviews: { status: 'pass', required: true, summary: '', reviewers: [], findings: [] },
+          diffReview: { status: 'pass', required: true, summary: '', reviewers: [], findings: [] }
+        },
+        blockingFindings: [],
+        timestamp: '2026-03-25T01:12:00.000Z'
+      }
+    );
+
+    for (const filePath of getIntentHandoffArtifactPaths(repoRoot, 'REQ-123')) {
+      if (filePath !== prBriefPath) {
+        writeText(filePath);
+      }
+    }
+
+    await syncIntentPrBrief(repoRoot, 'REQ-123');
+
+    const prBrief = fs.readFileSync(prBriefPath, 'utf8');
+
+    expect(prBrief).toContain('PR Brief: REQ-123');
+    expect(prBrief).toContain('Suggested Title: feat(req-123): Deliver autopilot memory bridge');
+    expect(prBrief).toContain('execution/tasks/T001/checkpoint.json');
+    expect(prBrief).toContain('execution/tasks/T002/checkpoint.json');
+    expect(prBrief).toContain('存在 1 个 skipped 任务，需要确认是否可接受：T002');
+    expect(prBrief).not.toContain('result.md');
+    for (const filePath of getIntentHandoffArtifactPaths(repoRoot, 'REQ-123')) {
+      expect(fs.existsSync(filePath)).toBe(filePath === prBriefPath);
+    }
+  });
+});

package/lib/skill-runtime/__tests__/lifecycle.test.js

@@ -0,0 +1,169 @@
+const {
+  deriveLifecycleStage,
+  deriveLifecycleNextAction,
+  classifyDelegationMode,
+  deriveTaskProgress,
+  getApprovalState,
+  isTaskCompletedStatus,
+  isTaskSettledStatus,
+  normalizeTaskStatus,
+  stageIndex
+} = require('../lifecycle');
+
+describe('lifecycle helpers', () => {
+  test('derives approve stage from an unapproved planned manifest and switches to delegate after approval', () => {
+    const state = {
+      changeId: 'REQ-123',
+      goal: 'Lock approval truth',
+      status: 'planned',
+      approval: {
+        status: 'pending',
+        executionMode: 'delegate'
+      }
+    };
+    const manifest = {
+      metadata: {
+        planVersion: 3
+      },
+      tasks: [
+        { id: 'T001', status: 'pending' }
+      ]
+    };
+
+    expect(deriveLifecycleStage({ state, manifest, report: null, hasPrBrief: false })).toBe('approve');
+    expect(getApprovalState(state, manifest)).toMatchObject({
+      status: 'pending',
+      executionMode: 'delegate',
+      planVersion: 3
+    });
+
+    const approvedState = {
+      ...state,
+      approval: {
+        status: 'approved',
+        executionMode: 'delegate',
+        planVersion: 3,
+        approvedAt: '2026-04-09T05:00:00.000Z'
+      }
+    };
+
+    expect(deriveLifecycleStage({ state: approvedState, manifest, report: null, hasPrBrief: false })).toBe('delegate');
+    expect(stageIndex('approve')).toBeLessThan(stageIndex('delegate'));
+  });
+
+  test('keeps team mode explicit opt-in when routing tasks', () => {
+    const task = {
+      id: 'T900',
+      title: 'Cross-module implementation',
+      type: 'IMPL',
+      dependsOn: ['T001', 'T002', 'T003'],
+      touches: ['a.ts', 'b.ts', 'c.ts', 'd.ts'],
+      run: ['echo one', 'echo two'],
+      checks: []
+    };
+
+    expect(classifyDelegationMode(task, { approval: { executionMode: 'delegate' } })).toBe('delegate');
+    expect(classifyDelegationMode(task, { approval: { executionMode: 'team' } })).toBe('team');
+  });
+
+  test('derives next action from shared lifecycle stage rules', () => {
+    const state = {
+      changeId: 'REQ-123',
+      goal: 'Lock approval truth',
+      status: 'planned',
+      approval: {
+        status: 'pending',
+        executionMode: 'delegate'
+      }
+    };
+    const manifest = {
+      metadata: {
+        planVersion: 3
+      },
+      tasks: [
+        { id: 'T001', status: 'pending' },
+        { id: 'T002', status: 'failed' }
+      ]
+    };
+
+    expect(deriveLifecycleNextAction({ state: null, manifest: null, report: null })).toBe(
+      '生成或刷新 task-manifest，然后回到批准闸。'
+    );
+    expect(deriveLifecycleNextAction({ state, manifest, report: null })).toBe(
+      '先批准当前计划版本 3，再进入执行。'
+    );
+
+    const approvedState = {
+      ...state,
+      approval: {
+        status: 'approved',
+        executionMode: 'delegate',
+        planVersion: 3,
+        approvedAt: '2026-04-09T05:00:00.000Z'
+      }
+    };
+
+    expect(deriveLifecycleNextAction({ state: approvedState, manifest, report: null })).toBe(
+      '优先修复失败任务 T002，然后从最近稳定 checkpoint 恢复。'
+    );
+    expect(
+      deriveLifecycleNextAction({
+        state: approvedState,
+        manifest: {
+          ...manifest,
+          tasks: [
+            { id: 'T001', status: 'passed' }
+          ]
+        },
+        report: { overall: 'pass' },
+        hasPrBrief: true
+      })
+    ).toBe('PR brief 已生成，可直接整理提交并创建 PR。');
+    expect(
+      deriveLifecycleNextAction({
+        state: approvedState,
+        manifest: {
+          ...manifest,
+          tasks: [
+            { id: 'T001', status: 'passed' }
+          ]
+        },
+        report: { overall: 'pass' },
+        hasReleaseNote: true
+      })
+    ).toBe('发布材料已经生成，可归档或启动下一轮增量。');
+  });
+
+  test('derives query progress from the shared task summary', () => {
+    expect(
+      deriveTaskProgress([
+        { id: 'T001', status: 'pending' },
+        { id: 'T002', status: 'running' },
+        { id: 'T003', status: 'passed' },
+        { id: 'T004', status: 'failed' },
+        { id: 'T005', status: 'skipped' },
+        { id: 'T006', status: 'custom-state' }
+      ])
+    ).toEqual({
+      totalTasks: 6,
+      completedTasks: 1,
+      failedTasks: 1,
+      pendingTasks: 1,
+      runningTasks: 1,
+      skippedTasks: 1
+    });
+  });
+
+  test('normalizes legacy completion aliases into shared lifecycle semantics', () => {
+    expect(normalizeTaskStatus('completed')).toBe('passed');
+    expect(normalizeTaskStatus('done')).toBe('passed');
+    expect(normalizeTaskStatus('verified')).toBe('passed');
+    expect(isTaskCompletedStatus('passed')).toBe(true);
+    expect(isTaskCompletedStatus('verified')).toBe(true);
+    expect(isTaskCompletedStatus('skipped')).toBe(false);
+    expect(isTaskSettledStatus('passed')).toBe(true);
+    expect(isTaskSettledStatus('verified')).toBe(true);
+    expect(isTaskSettledStatus('skipped')).toBe(true);
+    expect(isTaskSettledStatus('failed')).toBe(false);
+  });
+});

package/lib/skill-runtime/__tests__/paths.test.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  buildChangeKey,
+  getChangePaths,
+  getChangeSlug
+} = require('../paths');
+
+describe('change directory naming', () => {
+  test('builds new change keys with uppercase REQ/FIX prefixes', () => {
+    expect(buildChangeKey('REQ-123', { goal: 'Plan folder contract' }))
+      .toBe('REQ-123-plan-folder-contract');
+    expect(buildChangeKey('FIX-123', { goal: '修复 目录 命名' }))
+      .toBe('FIX-123-修复-目录-命名');
+  });
+
+  test('rejects change ids and explicit keys outside the canonical prefix contract', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-paths-'));
+
+    expect(() => buildChangeKey('BUG-123', { goal: 'legacy bug id' }))
+      .toThrow(/REQ-<number> or FIX-<number>/);
+    expect(() => getChangePaths(repoRoot, 'REQ-123', { changeKey: 'req-123-lowercase' }))
+      .toThrow(/Expected REQ-123-<description>/);
+
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  test('resolves legacy lowercase directories without creating a second path', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-paths-'));
+    const legacyDir = path.join(repoRoot, 'devflow', 'changes', 'req-123-existing-plan');
+    fs.mkdirSync(legacyDir, { recursive: true });
+
+    const paths = getChangePaths(repoRoot, 'REQ-123', { goal: 'Existing plan' });
+
+    expect(paths.changeDir).toBe(legacyDir);
+    expect(getChangeSlug('REQ-123', paths.changeKey)).toBe('existing-plan');
+
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+});

package/lib/skill-runtime/__tests__/planner.tdd.test.js

@@ -0,0 +1,250 @@
+/**
+ * TDD Order Validation Tests
+ *
+ * Tests for Constitution Article VI enforcement in planner.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { parseTasksMarkdown, createTaskManifest, deriveManifestExecutionState } = require('../planner');
+
+describe('TDD Order Validation', () => {
+  describe('Rich task metadata parsing', () => {
+    test('should preserve phase, files, acceptance, verification, evidence and context', () => {
+      const markdown = `
+## Phase 1: Foundation
+
+- [ ] T001 [TEST] Counter behavior (dependsOn:none) \`src/counter.test.ts\`
+  Goal: prove the current behavior is broken first
+  Files: \`src/counter.test.ts\`
+  Read first: \`design.md\`, \`tasks.md\`
+  Verification: npm test -- src/counter.test.ts
+  Evidence: failing output, screenshot
+
+- [ ] T002 [P] [IMPL] Counter behavior (dependsOn:T001) \`src/counter.ts\`
+  Goal: make the counter test pass
+  Files: \`src/counter.ts\`
+  Read first: \`design.md\`, \`src/counter.test.ts\`
+  Verification: npm test -- src/counter.test.ts
+  Evidence: passing output, review notes
+      `.trim();
+
+      const tasks = parseTasksMarkdown(markdown);
+
+      expect(tasks).toHaveLength(2);
+      expect(tasks[0]).toMatchObject({
+        id: 'T001',
+        phase: 1,
+        parallel: false,
+        type: 'TEST',
+        files: ['src/counter.test.ts'],
+        touches: ['src/counter.test.ts'],
+        acceptance: ['prove the current behavior is broken first'],
+        verification: ['npm test -- src/counter.test.ts'],
+        evidence: ['failing output', 'screenshot'],
+        reviews: { spec: 'pending', code: 'pending' }
+      });
+      expect(tasks[0].checks).toContain('npm test -- src/counter.test.ts');
+      expect(tasks[0].context.readFiles).toEqual(['design.md', 'tasks.md']);
+      expect(tasks[0].context.commands).toContain('npm test -- src/counter.test.ts');
+
+      expect(tasks[1]).toMatchObject({
+        id: 'T002',
+        phase: 1,
+        parallel: true,
+        type: 'IMPL',
+        files: ['src/counter.ts'],
+        touches: ['src/counter.ts'],
+        acceptance: ['make the counter test pass'],
+        verification: ['npm test -- src/counter.test.ts'],
+        evidence: ['passing output', 'review notes']
+      });
+      expect(tasks[1].context.readFiles).toEqual(['design.md', 'src/counter.test.ts']);
+    });
+
+    test('should backfill minimum metadata for TEST and IMPL tasks from plain TASKS lines', () => {
+      const markdown = `
+## Phase 1: Build
+
+- [ ] T001 [TEST] Counter behavior \`src/counter.test.ts\`
+- [ ] T002 [IMPL] Counter behavior (dependsOn:T001) \`src/counter.ts\`
+      `.trim();
+
+      const tasks = parseTasksMarkdown(markdown);
+
+      expect(tasks[0].acceptance).toEqual(['Prove Counter behavior fails before implementation']);
+      expect(tasks[0].verification).toEqual(['npm test -- src/counter.test.ts']);
+      expect(tasks[0].evidence).toEqual(['failing test output']);
+      expect(tasks[0].context.readFiles).toEqual(['design.md', 'tasks.md', 'src/counter.test.ts']);
+
+      expect(tasks[1].acceptance).toEqual(['Make Counter behavior pass with the smallest implementation']);
+      expect(tasks[1].verification).toEqual(['echo "verify T002"']);
+      expect(tasks[1].evidence).toEqual(['passing test output']);
+      expect(tasks[1].context.readFiles).toEqual(['design.md']);
+    });
+  });
+
+  describe('Manifest execution state', () => {
+    test('should derive active phase and current task from ready tasks', () => {
+      const state = deriveManifestExecutionState([
+        { id: 'T001', phase: 1, status: 'passed', dependsOn: [] },
+        { id: 'T002', phase: 2, status: 'pending', dependsOn: ['T001'] },
+        { id: 'T003', phase: 2, status: 'pending', dependsOn: ['T002'] }
+      ]);
+
+      expect(state).toEqual({
+        currentTaskId: 'T002',
+        activePhase: 2
+      });
+    });
+
+    test('should write currentTaskId and activePhase into manifest', async () => {
+      const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-planner-'));
+      const changeId = 'REQ-321';
+      const tasksPath = path.join(repoRoot, 'devflow', 'changes', `${changeId}-change`, 'planning', 'tasks.md');
+      fs.mkdirSync(path.dirname(tasksPath), { recursive: true });
+      fs.writeFileSync(
+        tasksPath,
+        [
+          '## Phase 1: Foundation',
+          '',
+          '- [x] T001 [TEST] Setup smoke test `src/setup.test.ts`',
+          '- [ ] T002 [IMPL] Setup smoke test (dependsOn:T001) `src/setup.ts`',
+          '',
+          '## Phase 2: Verify',
+          '',
+          '- [ ] T003 Run final verification'
+        ].join('\n')
+      );
+
+      const manifest = await createTaskManifest({
+        repoRoot,
+        changeId,
+        goal: 'Exercise manifest execution state',
+        overwrite: true
+      });
+
+      expect(manifest.activePhase).toBe(1);
+      expect(manifest.currentTaskId).toBe('T002');
+      expect(manifest.tasks[1].reviews).toEqual({ spec: 'pending', code: 'pending' });
+    });
+  });
+
+  describe('Valid TDD sequences', () => {
+    test('should accept TEST before IMPL with correct dependency', () => {
+      const markdown = `
+- [ ] T001 [TEST] 用户登录功能测试
+- [ ] T002 [IMPL] 用户登录功能实现 (dependsOn:T001)
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).not.toThrow();
+    });
+
+    test('should accept multiple TEST-IMPL pairs', () => {
+      const markdown = `
+- [ ] T001 [TEST] 用户登录测试
+- [ ] T002 [IMPL] 用户登录实现 (dependsOn:T001)
+- [ ] T003 [TEST] 用户注册测试 [P]
+- [ ] T004 [IMPL] 用户注册实现 (dependsOn:T003)
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).not.toThrow();
+    });
+
+    test('should accept tasks without TEST/IMPL markers', () => {
+      const markdown = `
+- [ ] T001 初始化项目结构
+- [ ] T002 配置开发环境
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).not.toThrow();
+    });
+  });
+
+  describe('TDD violations', () => {
+    test('should reject IMPL without corresponding TEST', () => {
+      const markdown = `
+- [ ] T001 [IMPL] 用户登录功能实现
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).toThrow(
+        /missing corresponding TEST task/
+      );
+    });
+
+    test('should reject IMPL not depending on TEST', () => {
+      const markdown = `
+- [ ] T001 [TEST] 用户登录功能测试
+- [ ] T002 [IMPL] 用户登录功能实现 [P]
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).toThrow(
+        /must depend on T001/
+      );
+    });
+
+    test('should reject TEST depending on IMPL', () => {
+      const markdown = `
+- [ ] T001 [IMPL] 用户登录功能实现
+- [ ] T002 [TEST] 用户登录功能测试 (dependsOn:T001)
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).toThrow(
+        /Tests must be written BEFORE implementation/
+      );
+    });
+
+    test('should reject IMPL depending on wrong TEST', () => {
+      const markdown = `
+- [ ] T001 [TEST] 用户注册测试
+- [ ] T002 [IMPL] 用户登录实现 (dependsOn:T001)
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).toThrow(
+        /missing corresponding TEST task/
+      );
+    });
+  });
+
+  describe('Feature name extraction', () => {
+    test('should match TEST and IMPL with same feature name', () => {
+      const markdown = `
+- [ ] T001 [TEST] 实现用户认证功能
+- [ ] T002 [IMPL] 实现用户认证功能 (dependsOn:T001)
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).not.toThrow();
+    });
+
+    test('should handle case-insensitive markers', () => {
+      const markdown = `
+- [ ] T001 [test] 用户登录
+- [ ] T002 [impl] 用户登录 (dependsOn:T001)
+      `.trim();
+
+      expect(() => parseTasksMarkdown(markdown)).not.toThrow();
+    });
+  });
+
+  describe('Error messages', () => {
+    test('should provide clear violation details', () => {
+      const markdown = `
+- [ ] T001 [IMPL] 功能A
+- [ ] T002 [TEST] 功能B
+- [ ] T003 [IMPL] 功能B
+      `.trim();
+
+      try {
+        parseTasksMarkdown(markdown);
+        fail('Should have thrown TDD violation error');
+      } catch (error) {
+        expect(error.message).toContain('TDD Order Validation Failed');
+        expect(error.message).toContain('Constitution Article VI');
+        expect(error.message).toContain('T001');
+        expect(error.message).toContain('missing corresponding TEST task');
+      }
+    });
+  });
+});