cc-devflow 4.3.0 → 4.5.0

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

@@ -0,0 +1,267 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { runDispatch } = require('../operations/dispatch');
+const { runResume } = require('../operations/resume');
+const {
+  getRuntimeStatePath,
+  getTaskManifestPath,
+  getCheckpointPath,
+  getEventsPath
+} = require('../store');
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+describe('runDispatch', () => {
+  test('blocks execution when the current plan version has not been approved', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-dispatch-unapproved-'));
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
+
+    writeJson(getRuntimeStatePath(repoRoot, 'REQ-123'), {
+      changeId: 'REQ-123',
+      changeKey: 'REQ-123-block-unapproved-execution',
+      slug: 'block-unapproved-execution',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      goal: 'Block unapproved execution',
+      status: 'planned',
+      initializedAt: '2026-03-25T01:00:00.000Z',
+      plannedAt: '2026-03-25T01:01:00.000Z',
+      approval: {
+        status: 'pending',
+        executionMode: 'delegate'
+      },
+      updatedAt: '2026-03-25T01:01:00.000Z'
+    });
+
+    writeJson(manifestPath, {
+      changeId: 'REQ-123',
+      goal: 'Block unapproved execution',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      updatedAt: '2026-03-25T01:01:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Should not execute before approval',
+          type: 'IMPL',
+          dependsOn: [],
+          touches: ['lib/skill-runtime/operations/dispatch.js'],
+          run: ['echo blocked'],
+          checks: [],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 0
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    const result = await runDispatch({
+      repoRoot,
+      changeId: 'REQ-123',
+      parallel: 1
+    });
+
+    const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+    expect(result.success).toBe(false);
+    expect(result.reason).toContain('cc-plan approval gate');
+    expect(nextManifest.tasks[0].status).toBe('pending');
+  });
+
+  test('rejects stale results when planVersion changes during task execution and records it in checkpoint', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-dispatch-'));
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
+
+    writeJson(getRuntimeStatePath(repoRoot, 'REQ-123'), {
+      changeId: 'REQ-123',
+      changeKey: 'REQ-123-reject-stale-results',
+      slug: 'reject-stale-results',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      goal: 'Reject stale results',
+      status: 'planned',
+      initializedAt: '2026-03-25T01:00:00.000Z',
+      plannedAt: '2026-03-25T01:01:00.000Z',
+      approval: {
+        status: 'approved',
+        executionMode: 'delegate',
+        planVersion: 1,
+        approvedAt: '2026-03-25T01:01:30.000Z'
+      },
+      updatedAt: '2026-03-25T01:01:00.000Z'
+    });
+
+    writeJson(manifestPath, {
+      changeId: 'REQ-123',
+      goal: 'Reject stale results',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      updatedAt: '2026-03-25T01:01:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Mutate plan version mid-flight',
+          type: 'IMPL',
+          dependsOn: [],
+          touches: ['lib/skill-runtime/operations/dispatch.js'],
+          run: [
+            `node -e "const fs=require('fs'); const p='${manifestPath.replace(/\\/g, '\\\\')}'; const data=JSON.parse(fs.readFileSync(p,'utf8')); data.metadata.planVersion=2; fs.writeFileSync(p, JSON.stringify(data, null, 2)+'\\n');"`
+          ],
+          checks: [],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 0
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    const result = await runDispatch({
+      repoRoot,
+      changeId: 'REQ-123',
+      parallel: 1
+    });
+
+    const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const checkpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T001'), 'utf8'));
+    const events = fs.readFileSync(getEventsPath(repoRoot, 'REQ-123', 'T001'), 'utf8');
+
+    expect(result.success).toBe(false);
+    expect(nextManifest.tasks[0].status).toBe('failed');
+    expect(nextManifest.tasks[0].lastError).toContain('Stale result rejected');
+    expect(checkpoint.planVersion).toBe(1);
+    expect(checkpoint.error).toContain('Stale result rejected');
+    expect(events).toContain('task_stale_rejected');
+  });
+
+  test('restores unresolved work from the latest stable checkpoint on resume without creating handoff markdown', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-resume-stable-'));
+    const changeId = 'REQ-123';
+    const manifestPath = getTaskManifestPath(repoRoot, changeId);
+
+    writeJson(getRuntimeStatePath(repoRoot, changeId), {
+      changeId,
+      changeKey: 'REQ-123-recover-from-stable-checkpoint',
+      slug: 'recover-from-stable-checkpoint',
+      createdAt: '2026-04-09T01:00:00.000Z',
+      goal: 'Recover from stable checkpoint',
+      status: 'in_progress',
+      initializedAt: '2026-04-09T01:00:00.000Z',
+      plannedAt: '2026-04-09T01:01:00.000Z',
+      approval: {
+        status: 'approved',
+        executionMode: 'delegate',
+        planVersion: 1,
+        approvedAt: '2026-04-09T01:01:30.000Z'
+      },
+      updatedAt: '2026-04-09T01:02:00.000Z'
+    });
+
+    writeJson(manifestPath, {
+      changeId,
+      goal: 'Recover from stable checkpoint',
+      createdAt: '2026-04-09T01:00:00.000Z',
+      updatedAt: '2026-04-09T01:02:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Stable checkpoint task',
+          type: 'TEST',
+          dependsOn: [],
+          touches: ['src/a.ts'],
+          run: ['node -e "process.exit(0)"'],
+          checks: [],
+          status: 'passed',
+          attempts: 1,
+          maxRetries: 0
+        },
+        {
+          id: 'T002',
+          title: 'Retry-exhausted failed task',
+          type: 'IMPL',
+          dependsOn: ['T001'],
+          touches: ['src/b.ts'],
+          run: ['node -e "process.exit(0)"'],
+          checks: [],
+          status: 'failed',
+          attempts: 2,
+          maxRetries: 1,
+          lastError: 'Command failed'
+        },
+        {
+          id: 'T003',
+          title: 'Task skipped by failed dependency',
+          type: 'IMPL',
+          dependsOn: ['T002'],
+          touches: ['src/c.ts'],
+          run: ['node -e "process.exit(0)"'],
+          checks: [],
+          status: 'skipped',
+          attempts: 0,
+          maxRetries: 0,
+          lastError: 'Blocked by failed dependency'
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    writeJson(getCheckpointPath(repoRoot, changeId, 'T001'), {
+      changeId,
+      taskId: 'T001',
+      sessionId: 'stable-session',
+      planVersion: 1,
+      status: 'passed',
+      summary: 'Task passed after 1 attempt(s)',
+      error: '',
+      outputExcerpt: '',
+      timestamp: '2026-04-09T01:05:00.000Z',
+      attempt: 1
+    });
+
+    writeJson(getCheckpointPath(repoRoot, changeId, 'T002'), {
+      changeId,
+      taskId: 'T002',
+      sessionId: 'failed-session',
+      planVersion: 1,
+      status: 'failed',
+      summary: 'Task failed: Command failed',
+      error: 'Command failed',
+      outputExcerpt: 'Command failed',
+      timestamp: '2026-04-09T01:06:00.000Z',
+      attempt: 2
+    });
+
+    const result = await runResume({
+      repoRoot,
+      changeId,
+      parallel: 1,
+      fromCheckpoint: 'stable'
+    });
+
+    const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+    expect(result.success).toBe(true);
+    expect(result.restoredCheckpoint).toMatchObject({
+      taskId: 'T001',
+      status: 'passed'
+    });
+    expect(result.restoredTasks).toEqual(['T002', 'T003']);
+    expect(nextManifest.tasks.map((task) => task.status)).toEqual(['passed', 'passed', 'passed']);
+    expect(nextManifest.tasks[1].attempts).toBe(1);
+    expect(nextManifest.tasks[2].attempts).toBe(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 });
+  });
+});