cc-devflow 4.5.10 → 4.5.12

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

@@ -1,237 +0,0 @@
-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,
-  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 manifest and events', 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 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(events).toContain('task_stale_rejected');
-  });
-
-  test('restores unresolved work from the latest stable manifest state 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-state',
-      slug: 'recover-from-stable-state',
-      createdAt: '2026-04-09T01:00:00.000Z',
-      goal: 'Recover from stable state',
-      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 state',
-      createdAt: '2026-04-09T01:00:00.000Z',
-      updatedAt: '2026-04-09T01:02:00.000Z',
-      tasks: [
-        {
-          id: 'T001',
-          title: 'Stable completed 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
-      }
-    });
-
-    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.restoredState).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

@@ -1,203 +0,0 @@
-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
-} = 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
-        }
-      }
-    );
-
-  });
-
-  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 task state 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('planning/tasks.md');
-    expect(prBrief).toContain('planning/task-manifest.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

@@ -1,169 +0,0 @@
-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，然后从 task-manifest 的最近稳定状态恢复。'
-    );
-    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);
-  });
-});