cc-devflow 4.3.0 → 4.5.0

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

@@ -0,0 +1,281 @@
+/**
+ * [INPUT]: 依赖 skill runtime operations 与临时仓库夹具。
+ * [OUTPUT]: 验证 plan/do/check/act 共享运行时主链最小可运行性。
+ * [POS]: lib/skill-runtime/__tests__ 的集成测试入口，保障 skill-first 内核回归。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+
+const { runInit } = require('../operations/init');
+const { runPlanningSnapshot } = require('../operations/snapshot');
+const { runPlan } = require('../operations/plan');
+const { runApprove } = require('../operations/approve');
+const { runDispatch } = require('../operations/dispatch');
+const { runVerify } = require('../operations/verify');
+const { runRelease } = require('../operations/release');
+const {
+  getTaskManifestPath,
+  getReportCardPath,
+  getReleaseNotePath,
+  getTasksMarkdownPath,
+  readJson,
+  readText
+} = require('../store');
+const { getChangePaths } = require('../paths');
+
+const WRITE_TASK_CHECKPOINT = path.join(
+  REPO_ROOT,
+  '.claude/skills/cc-do/scripts/write-task-checkpoint.sh'
+);
+const RECORD_REVIEW_DECISION = path.join(
+  REPO_ROOT,
+  '.claude/skills/cc-do/scripts/record-review-decision.sh'
+);
+const VERIFY_TASK_GATES = path.join(
+  REPO_ROOT,
+  '.claude/skills/cc-do/scripts/verify-task-gates.sh'
+);
+const MARK_TASK_COMPLETE = path.join(
+  REPO_ROOT,
+  '.claude/skills/cc-do/scripts/mark-task-complete.sh'
+);
+
+jest.setTimeout(20000);
+
+describe('Skill runtime', () => {
+  let repoRoot;
+
+  beforeEach(() => {
+    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-runtime-'));
+
+    fs.writeFileSync(
+      path.join(repoRoot, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'tmp-repo',
+          version: '0.0.0',
+          scripts: {
+            lint: 'node -e "process.exit(0)"',
+            typecheck: 'node -e "process.exit(0)"',
+            test: 'node -e "process.exit(0)"'
+          }
+        },
+        null,
+        2
+      )
+    );
+
+    fs.mkdirSync(path.join(repoRoot, '.git'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  async function markManifestReviews(changeId, verdict = 'pass') {
+    const manifestPath = getTaskManifestPath(repoRoot, changeId);
+    const manifest = await readJson(manifestPath);
+    manifest.tasks = manifest.tasks.map((task) => ({
+      ...task,
+      reviews: {
+        spec: verdict,
+        code: verdict
+      }
+    }));
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  }
+
+  test('runs init -> snapshot -> plan -> dispatch -> verify -> release', async () => {
+    const changeId = 'REQ-999';
+    await runInit({ repoRoot, changeId, goal: 'Test skill runtime pipeline' });
+
+    fs.writeFileSync(
+      getTasksMarkdownPath(repoRoot, changeId),
+      [
+        '- [ ] T001 create scaffolding (src/a.ts)',
+        '- [ ] T002 [P] add docs (docs/readme.md)',
+        '- [ ] T003 finalize dependsOn:T001,T002 (src/b.ts)'
+      ].join('\n')
+    );
+
+    await runPlanningSnapshot({ repoRoot, changeId });
+
+    const planResult = await runPlan({ repoRoot, changeId, overwrite: true });
+    expect(planResult.taskCount).toBe(3);
+    await runApprove({ repoRoot, changeId, executionMode: 'direct' });
+
+    const dispatchResult = await runDispatch({
+      repoRoot,
+      changeId,
+      parallel: 2,
+      maxRetries: 0
+    });
+    expect(dispatchResult.success).toBe(true);
+
+    const manifest = await readJson(getTaskManifestPath(repoRoot, changeId));
+    expect(manifest.tasks.every((task) => task.status === 'passed')).toBe(true);
+
+    await markManifestReviews(changeId, 'pass');
+
+    const verifyResult = await runVerify({
+      repoRoot,
+      changeId,
+      strict: false,
+      skipReview: true
+    });
+    expect(verifyResult.overall).toBe('pass');
+
+    const report = await readJson(getReportCardPath(repoRoot, changeId));
+    expect(report.overall).toBe('pass');
+
+    const releaseResult = await runRelease({ repoRoot, changeId });
+    expect(releaseResult.status).toBe('released');
+
+    const releaseNote = await readText(getReleaseNotePath(repoRoot, changeId));
+    expect(releaseNote).toContain('Release Note - REQ-999');
+  });
+
+  test('blocks verify when passed tasks are missing native review proof', async () => {
+    const changeId = 'REQ-1000';
+    await runInit({ repoRoot, changeId, goal: 'Require task review proof' });
+
+    fs.writeFileSync(
+      getTasksMarkdownPath(repoRoot, changeId),
+      [
+        '- [ ] T001 [TEST] Counter behavior (src/a.test.ts)',
+        '- [ ] T002 [IMPL] Counter behavior dependsOn:T001 (src/a.ts)'
+      ].join('\n')
+    );
+
+    await runPlanningSnapshot({ repoRoot, changeId });
+    await runPlan({ repoRoot, changeId, overwrite: true });
+    await runApprove({ repoRoot, changeId, executionMode: 'direct' });
+    await runDispatch({ repoRoot, changeId, parallel: 1, maxRetries: 0 });
+
+    const verifyResult = await runVerify({
+      repoRoot,
+      changeId,
+      strict: false,
+      skipReview: true
+    });
+
+    expect(verifyResult.overall).toBe('fail');
+
+    const report = await readJson(getReportCardPath(repoRoot, changeId));
+    expect(report.review.status).toBe('blocked');
+    expect(report.blockingFindings.some((item) => item.includes('missing spec review proof'))).toBe(true);
+  });
+
+  test('cc-do shell helpers write runtime artifacts into devflow/changes instead of legacy flat paths', async () => {
+    const changeId = 'REQ-2001';
+    await runInit({ repoRoot, changeId, goal: 'Verify shell helper layout' });
+
+    const change = getChangePaths(repoRoot, changeId, { goal: 'Verify shell helper layout' });
+    const manifestPath = getTaskManifestPath(repoRoot, changeId, { goal: 'Verify shell helper layout' });
+    fs.writeFileSync(
+      manifestPath,
+      `${JSON.stringify(
+        {
+          changeId,
+          tasks: [
+            {
+              id: 'T001',
+              title: 'Verify helper layout',
+              reviews: { spec: 'pending', code: 'pending' }
+            }
+          ]
+        },
+        null,
+        2
+      )}\n`
+    );
+
+    const checkpoint = spawnSync(WRITE_TASK_CHECKPOINT, [
+      '--dir',
+      change.changeDir,
+      '--task',
+      'T001',
+      '--status',
+      'passed',
+      '--summary',
+      'task finished'
+    ], { encoding: 'utf8' });
+    expect(checkpoint.status).toBe(0);
+
+    const specReview = spawnSync(RECORD_REVIEW_DECISION, [
+      '--dir',
+      change.changeDir,
+      '--task',
+      'T001',
+      '--gate',
+      'spec',
+      '--verdict',
+      'pass',
+      '--summary',
+      'spec ok'
+    ], { encoding: 'utf8' });
+    expect(specReview.status).toBe(0);
+
+    const codeReview = spawnSync(RECORD_REVIEW_DECISION, [
+      '--dir',
+      change.changeDir,
+      '--task',
+      'T001',
+      '--gate',
+      'code',
+      '--verdict',
+      'pass',
+      '--summary',
+      'code ok'
+    ], { encoding: 'utf8' });
+    expect(codeReview.status).toBe(0);
+
+    const verify = spawnSync(VERIFY_TASK_GATES, [
+      '--dir',
+      change.changeDir,
+      '--task',
+      'T001'
+    ], { encoding: 'utf8' });
+    expect(verify.status).toBe(0);
+
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'checkpoint.json'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.harness', 'runtime', changeId))).toBe(false);
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'checkpoint.md'))).toBe(false);
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'review-spec.md'))).toBe(false);
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'review-code.md'))).toBe(false);
+  });
+
+  test('mark-task-complete updates only the first matching task line on Darwin-compatible userlands', () => {
+    const tasksPath = path.join(repoRoot, 'tasks.md');
+    fs.writeFileSync(
+      tasksPath,
+      [
+        '- [ ] **T001** first task',
+        '- [ ] T001 second task',
+        '- [ ] T002 untouched'
+      ].join('\n')
+    );
+
+    const result = spawnSync(MARK_TASK_COMPLETE, [
+      '--tasks',
+      tasksPath,
+      '--task',
+      'T001'
+    ], { encoding: 'utf8' });
+
+    expect(result.status).toBe(0);
+    expect(fs.readFileSync(tasksPath, 'utf8').trimEnd()).toBe(
+      [
+        '- [x] **T001** first task',
+        '- [ ] T001 second task',
+        '- [ ] T002 untouched'
+      ].join('\n')
+    );
+  });
+});

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

@@ -0,0 +1,207 @@
+const { parseManifest } = require('../schemas');
+
+describe('Manifest schema hard constraints', () => {
+  test('accepts a tasks.md manifest with review and context metadata', () => {
+    const manifest = parseManifest({
+      changeId: 'REQ-555',
+      goal: 'Validate schema contract',
+      createdAt: '2026-04-10T01:00:00.000Z',
+      updatedAt: '2026-04-10T01:05:00.000Z',
+      currentTaskId: 'T001',
+      activePhase: 1,
+      tasks: [
+        {
+          id: 'T001',
+          title: '[TEST] Counter behavior',
+          type: 'TEST',
+          phase: 1,
+          parallel: false,
+          dependsOn: [],
+          touches: ['src/counter.test.ts'],
+          files: ['src/counter.test.ts'],
+          run: ['echo "[TASK T001] Counter behavior"'],
+          checks: ['npm test -- src/counter.test.ts'],
+          acceptance: ['Prove counter behavior fails first'],
+          verification: ['npm test -- src/counter.test.ts'],
+          evidence: ['failing test output'],
+          context: {
+            readFiles: ['design.md', 'tasks.md'],
+            commands: ['npm test -- src/counter.test.ts'],
+            notes: ['Start from red']
+          },
+          reviews: {
+            spec: 'pending',
+            code: 'pending'
+          },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        },
+        {
+          id: 'T002',
+          title: '[IMPL] Counter behavior',
+          type: 'IMPL',
+          phase: 1,
+          parallel: false,
+          dependsOn: ['T001'],
+          touches: ['src/counter.ts'],
+          files: ['src/counter.ts'],
+          run: ['echo "[TASK T002] Counter behavior"'],
+          checks: ['npm test -- src/counter.test.ts'],
+          acceptance: ['Make counter behavior pass'],
+          verification: ['npm test -- src/counter.test.ts'],
+          evidence: ['passing test output'],
+          context: {
+            readFiles: ['design.md', 'src/counter.test.ts'],
+            commands: ['npm test -- src/counter.test.ts'],
+            notes: ['Smallest green implementation']
+          },
+          reviews: {
+            spec: 'pending',
+            code: 'pending'
+          },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'tasks.md',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    expect(manifest.currentTaskId).toBe('T001');
+    expect(manifest.activePhase).toBe(1);
+  });
+
+  test('rejects invalid currentTaskId for tasks.md manifest', () => {
+    expect(() => parseManifest({
+      changeId: 'REQ-556',
+      goal: 'Reject invalid current task',
+      createdAt: '2026-04-10T01:00:00.000Z',
+      updatedAt: '2026-04-10T01:05:00.000Z',
+      currentTaskId: 'T999',
+      activePhase: 1,
+      tasks: [
+        {
+          id: 'T001',
+          title: '[TEST] Counter behavior',
+          type: 'TEST',
+          phase: 1,
+          dependsOn: [],
+          run: ['echo ok'],
+          checks: ['npm test -- src/counter.test.ts'],
+          acceptance: ['Prove failure'],
+          verification: ['npm test -- src/counter.test.ts'],
+          evidence: ['failing test output'],
+          context: {
+            readFiles: ['design.md'],
+            commands: ['npm test -- src/counter.test.ts'],
+            notes: []
+          },
+          reviews: {
+            spec: 'pending',
+            code: 'pending'
+          },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'tasks.md',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    })).toThrow(/currentTaskId T999 is not present/);
+  });
+
+  test('accepts FIX ids and rejects legacy BUG ids', () => {
+    const baseManifest = {
+      goal: 'Validate fix id',
+      createdAt: '2026-04-10T01:00:00.000Z',
+      updatedAt: '2026-04-10T01:05:00.000Z',
+      currentTaskId: 'T001',
+      activePhase: 1,
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Bootstrap fix',
+          type: 'OTHER',
+          phase: 1,
+          dependsOn: [],
+          run: ['echo ok'],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    };
+
+    expect(parseManifest({ ...baseManifest, changeId: 'FIX-556' }).changeId).toBe('FIX-556');
+    expect(() => parseManifest({ ...baseManifest, changeId: 'BUG-556' })).toThrow(/Invalid changeId format/);
+  });
+
+  test('rejects conflicting parallel tasks that share touches in same phase', () => {
+    expect(() => parseManifest({
+      changeId: 'REQ-557',
+      goal: 'Reject bad parallel plan',
+      createdAt: '2026-04-10T01:00:00.000Z',
+      updatedAt: '2026-04-10T01:05:00.000Z',
+      currentTaskId: 'T001',
+      activePhase: 1,
+      tasks: [
+        {
+          id: 'T001',
+          title: '[TEST] A',
+          type: 'TEST',
+          phase: 1,
+          parallel: true,
+          dependsOn: [],
+          touches: ['src/shared.ts'],
+          run: ['echo ok'],
+          checks: ['npm test -- a'],
+          acceptance: ['Prove A fails'],
+          verification: ['npm test -- a'],
+          evidence: ['failing output'],
+          context: { readFiles: ['design.md'], commands: ['npm test -- a'], notes: [] },
+          reviews: { spec: 'pending', code: 'pending' },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        },
+        {
+          id: 'T002',
+          title: '[TEST] B',
+          type: 'TEST',
+          phase: 1,
+          parallel: true,
+          dependsOn: [],
+          touches: ['src/shared.ts'],
+          run: ['echo ok'],
+          checks: ['npm test -- b'],
+          acceptance: ['Prove B fails'],
+          verification: ['npm test -- b'],
+          evidence: ['failing output'],
+          context: { readFiles: ['design.md'], commands: ['npm test -- b'], notes: [] },
+          reviews: { spec: 'pending', code: 'pending' },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'tasks.md',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    })).toThrow(/share touches/);
+  });
+});

package/lib/skill-runtime/__tests__/team-state.test.js

@@ -0,0 +1,51 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  getTeamStatePath,
+  readTeamState,
+  writeTeamState
+} = require('../team-state');
+
+describe('team-state', () => {
+  test('writes and reads the canonical truth state', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-team-state-'));
+    fs.writeFileSync(path.join(repoRoot, 'package.json'), JSON.stringify({ name: 'team-state-smoke', version: '1.0.0' }, null, 2));
+
+    await writeTeamState(repoRoot, 'REQ-123', {
+      status: 'delegated',
+      phase: 'delegate',
+      branch: 'main',
+      planVersion: 4,
+      team: {
+        mode: 'parallel',
+        lead: 'main-agent',
+        teammates: [
+          {
+            id: 'delegate-01',
+            role: 'dev-implementer',
+            status: 'idle',
+            currentTask: null,
+            completedTasks: [],
+            lastActiveAt: '2026-03-26T00:00:00.000Z'
+          }
+        ],
+        taskAssignments: {
+          T001: 'delegate-01'
+        },
+        createdAt: '2026-03-26T00:00:00.000Z',
+        updatedAt: '2026-03-26T00:00:00.000Z'
+      }
+    });
+
+    const truth = JSON.parse(fs.readFileSync(getTeamStatePath(repoRoot, 'REQ-123'), 'utf8'));
+    const state = await readTeamState(repoRoot, 'REQ-123');
+
+    expect(truth.changeId).toBe('REQ-123');
+    expect(truth.team.taskAssignments.T001).toBe('delegate-01');
+    expect(state.changeId).toBe('REQ-123');
+    expect(state.planVersion).toBe(4);
+    expect(state.phase).toBe('delegate');
+  });
+});