cc-devflow 4.5.9 → 4.5.10

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

@@ -101,6 +101,41 @@ describe('Skill runtime', () => {
     fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
   }
 
+  function writeCleanReviewLedger(changeId) {
+    const change = getChangePaths(repoRoot, changeId);
+    const ledgerPath = path.join(change.reviewDir, 'review-ledger.jsonl');
+    fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+    fs.writeFileSync(ledgerPath, [
+      JSON.stringify({
+        schema: 'review-ledger.v2',
+        change: change.changeKey,
+        reviewId: 'RVW-20260512-001',
+        createdAt: '2026-05-12T00:00:00.000Z',
+        createdBy: 'cc-devflow-cli',
+        event: 'review-started',
+        mode: 'implementation',
+        scope: 'current-diff',
+        baseSha: 'abc123',
+        headSha: 'def456',
+        selectedNodes: [],
+        skippedNodes: [],
+        riskLanes: []
+      }),
+      JSON.stringify({
+        schema: 'review-ledger.v2',
+        change: change.changeKey,
+        reviewId: 'RVW-20260512-001',
+        createdAt: '2026-05-12T00:01:00.000Z',
+        createdBy: 'cc-devflow-cli',
+        event: 'review-closed',
+        status: 'clean',
+        blockingCount: 0,
+        warningCount: 0,
+        next: 'cc-check'
+      })
+    ].join('\n'));
+  }
+
   test('runs init -> snapshot -> plan -> dispatch -> verify -> release', async () => {
     const changeId = 'REQ-999';
     await runInit({ repoRoot, changeId, goal: 'Test skill runtime pipeline' });
@@ -133,6 +168,7 @@ describe('Skill runtime', () => {
 
     await markManifestSpec(changeId);
     await markManifestReviews(changeId, 'pass');
+    writeCleanReviewLedger(changeId);
 
     const verifyResult = await runVerify({
       repoRoot,
@@ -144,6 +180,11 @@ describe('Skill runtime', () => {
 
     const report = await readJson(getReportCardPath(repoRoot, changeId));
     expect(report.overall).toBe('pass');
+    const requirementsMet = report.claimEvidence.find((claim) => claim.claim === 'requirements-met');
+    expect(requirementsMet).toMatchObject({
+      status: 'pass',
+      keyObservation: 'no open task gaps recorded'
+    });
 
     const releaseResult = await runRelease({ repoRoot, changeId });
     expect(releaseResult.status).toBe('released');
@@ -183,7 +224,7 @@ describe('Skill runtime', () => {
     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 () => {
+  test('cc-do shell helpers keep task truth in manifest and do not write process files by default', async () => {
     const changeId = 'REQ-2001';
     await runInit({ repoRoot, changeId, goal: 'Verify shell helper layout' });
 
@@ -207,7 +248,7 @@ describe('Skill runtime', () => {
       )}\n`
     );
 
-    const checkpoint = spawnSync(WRITE_TASK_CHECKPOINT, [
+    const legacyCheckpoint = spawnSync(WRITE_TASK_CHECKPOINT, [
       '--dir',
       change.changeDir,
       '--task',
@@ -215,24 +256,9 @@ describe('Skill runtime', () => {
       '--status',
       'passed',
       '--summary',
-      'task finished',
-      '--tdd-json',
-      JSON.stringify({
-        red: {
-          testSeam: 'public helper command',
-          behaviorAsserted: 'checkpoint is written under execution/tasks',
-          allowedMocks: [],
-          implementationDetailRisk: 'low'
-        },
-        testQuality: {
-          usesPublicInterface: true,
-          describesBehavior: true,
-          survivesInternalRefactor: true,
-          mocksOnlySystemBoundaries: true
-        }
-      })
+      'task finished'
     ], { encoding: 'utf8' });
-    expect(checkpoint.status).toBe(0);
+    expect(legacyCheckpoint.status).toBe(0);
 
     const specReview = spawnSync(RECORD_REVIEW_DECISION, [
       '--dir',
@@ -270,10 +296,25 @@ describe('Skill runtime', () => {
     ], { encoding: 'utf8' });
     expect(verify.status).toBe(0);
 
-    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'checkpoint.json'))).toBe(true);
-    const checkpointJson = JSON.parse(fs.readFileSync(path.join(change.tasksDir, 'T001', 'checkpoint.json'), 'utf8'));
-    expect(checkpointJson.tdd.red.testSeam).toBe('public helper command');
-    expect(checkpointJson.tdd.testQuality.usesPublicInterface).toBe(true);
+    const complete = spawnSync(MARK_TASK_COMPLETE, [
+      '--manifest',
+      manifestPath,
+      '--task',
+      'T001'
+    ], { encoding: 'utf8' });
+    expect(complete.status).toBe(0);
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    expect(manifest.currentTaskId).toBeNull();
+    expect(manifest.tasks[0]).toMatchObject({
+      id: 'T001',
+      status: 'passed',
+      reviews: { spec: 'pass', code: 'pass' }
+    });
+
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'checkpoint.json'))).toBe(false);
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'context.md'))).toBe(false);
+    expect(fs.existsSync(path.join(change.tasksDir, 'T001', 'events.jsonl'))).toBe(false);
     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);

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

@@ -180,6 +180,49 @@ describe('Manifest schema hard constraints', () => {
     expect(() => parseManifest({ ...baseManifest, changeId: 'BUG-556' })).toThrow(/Invalid changeId format/);
   });
 
+  test('accepts current full change keys and review/verification task types', () => {
+    const manifest = parseManifest({
+      changeId: 'REQ-001-personal-output-config',
+      goal: 'Validate current manifest shape',
+      createdAt: '2026-04-10T01:00:00.000Z',
+      updatedAt: '2026-04-10T01:05:00.000Z',
+      currentTaskId: 'T007',
+      tasks: [
+        {
+          id: 'T007',
+          title: '[REFACTOR] Apply review fixes',
+          type: 'REFACTOR',
+          phase: 4,
+          dependsOn: [],
+          run: ['echo ok'],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        },
+        {
+          id: 'T008',
+          title: '[VERIFY] Run full gates',
+          type: 'VERIFY',
+          phase: 4,
+          dependsOn: ['T007'],
+          run: ['npm test'],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'planning/tasks.md',
+        generatedBy: 'cc-plan',
+        planVersion: 1
+      }
+    });
+
+    expect(manifest.changeId).toBe('REQ-001-personal-output-config');
+    expect(manifest.tasks.map((task) => task.type)).toEqual(['REFACTOR', 'VERIFY']);
+    expect(manifest.metadata.source).toBe('planning/tasks.md');
+  });
+
   test('rejects conflicting parallel tasks that share touches in same phase', () => {
     expect(() => parseManifest({
       changeId: 'REQ-557',

package/lib/skill-runtime/__tests__/task-contract-migrate.test.js

@@ -0,0 +1,137 @@
+/**
+ * [INPUT]: 依赖 task-contract migrate operation、真实临时文件树与 CLI 子进程。
+ * [OUTPUT]: 证明 opt-in migrate 会折叠 legacy design.md，并归档原文件。
+ * [POS]: REQ-003-minimize-workflow-artifacts T007 的 Red/Green 证据。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { extractTasksContractSummary } = require('../task-contract');
+const { runCompile, runMigrate } = require('../operations/task-contract');
+
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+const CLI_BIN = path.join(REPO_ROOT, 'bin/cc-devflow-cli.js');
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+function legacyTasks() {
+  return [
+    '# TASKS',
+    '',
+    '## Plan Meta',
+    '',
+    '- Requirement version: `REQ-999-legacy.v1`',
+    '',
+    '## Phase 1: Legacy',
+    '',
+    '- [ ] T001 keep old behavior',
+    '  Goal: Preserve the migration source task list.',
+    ''
+  ].join('\n');
+}
+
+function legacyDesign() {
+  return [
+    '# DESIGN',
+    '',
+    '## Requirement Snapshot',
+    '',
+    '- Raw ask: Keep one source of truth.',
+    '',
+    '## Approved Direction',
+    '',
+    '- Fold legacy design into tasks.md only when explicitly requested.',
+    ''
+  ].join('\n');
+}
+
+describe('task-contract migrate', () => {
+  let repoRoot;
+
+  beforeEach(() => {
+    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-task-migrate-'));
+    fs.writeFileSync(path.join(repoRoot, 'package.json'), '{"name":"tmp"}\n');
+    fs.mkdirSync(path.join(repoRoot, '.git'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  test('migrate fold-design merges design.md content into tasks.md Contract Summary', async () => {
+    const changeId = 'REQ-999';
+    const changeKey = 'REQ-999-legacy';
+    const changeDir = path.join(repoRoot, 'devflow', 'changes', changeKey);
+    const planningDir = path.join(changeDir, 'planning');
+    writeFile(path.join(planningDir, 'tasks.md'), legacyTasks());
+    writeFile(path.join(planningDir, 'design.md'), legacyDesign());
+
+    const result = await runMigrate({ repoRoot, changeId, changeKey, foldDesign: true });
+    const tasksText = fs.readFileSync(path.join(planningDir, 'tasks.md'), 'utf8');
+    const archivedDesign = path.join(changeDir, 'assets', 'legacy', 'design.md.bak');
+
+    expect(result).toEqual(expect.objectContaining({
+      code: 0,
+      changeId,
+      changeKey,
+      migrated: ['design.md']
+    }));
+    expect(extractTasksContractSummary(tasksText).found).toBe(true);
+    expect(tasksText).toContain('## Contract Summary');
+    expect(tasksText).toContain('Legacy Design:');
+    expect(tasksText).toContain('> # DESIGN');
+    expect(tasksText).toContain('> - Fold legacy design into tasks.md only when explicitly requested.');
+    expect(fs.existsSync(path.join(planningDir, 'design.md'))).toBe(false);
+    expect(fs.readFileSync(archivedDesign, 'utf8')).toBe(legacyDesign());
+  });
+
+  test('compile does not auto-run fold-design migration', async () => {
+    const changeId = 'REQ-998';
+    const changeKey = 'REQ-998-no-auto-migrate';
+    const planningDir = path.join(repoRoot, 'devflow', 'changes', changeKey, 'planning');
+    writeFile(path.join(planningDir, 'tasks.md'), legacyTasks());
+    writeFile(path.join(planningDir, 'design.md'), legacyDesign());
+
+    const result = await runCompile({ repoRoot, changeId, changeKey });
+
+    expect(result.code).toBe(3);
+    expect(fs.existsSync(path.join(planningDir, 'design.md'))).toBe(true);
+  });
+
+  test('migrate returns exit code 4 when legacy design.md is unreadable', async () => {
+    const changeId = 'REQ-997';
+    const changeKey = 'REQ-997-unreadable-design';
+    const planningDir = path.join(repoRoot, 'devflow', 'changes', changeKey, 'planning');
+    writeFile(path.join(planningDir, 'tasks.md'), legacyTasks());
+    fs.mkdirSync(path.join(planningDir, 'design.md'), { recursive: true });
+
+    const result = await runMigrate({ repoRoot, changeId, changeKey, foldDesign: true });
+
+    expect(result.code).toBe(4);
+    expect(result.error).toContain('Unable to read planning/design.md');
+  });
+
+  test('CLI migrate requires an explicit fold flag', () => {
+    const changeId = 'REQ-996';
+    const changeKey = 'REQ-996-cli-flags';
+    const planningDir = path.join(repoRoot, 'devflow', 'changes', changeKey, 'planning');
+    writeFile(path.join(planningDir, 'tasks.md'), legacyTasks());
+    writeFile(path.join(planningDir, 'design.md'), legacyDesign());
+
+    const result = spawnSync(
+      process.execPath,
+      [CLI_BIN, 'task-contract', 'migrate', '--cwd', repoRoot, '--change', changeId, '--change-key', changeKey],
+      { encoding: 'utf8' }
+    );
+
+    expect(result.status).toBe(3);
+    expect(result.stderr).toContain('--fold-design');
+    expect(fs.existsSync(path.join(planningDir, 'design.md'))).toBe(true);
+  });
+});