cc-devflow 4.5.8 → 4.5.10

package/lib/skill-runtime/__tests__/verify-artifacts.test.js

@@ -0,0 +1,203 @@
+/**
+ * [INPUT]: 依赖 scripts/verify-artifacts.js 导出的 runVerifyArtifacts 和临时 change fixture。
+ * [OUTPUT]: 验证 verify:artifacts 只实现 C1-C10，返回稳定 exit code 和 JSON 报告。
+ * [POS]: REQ-003-minimize-workflow-artifacts T016 的 Red/Green 证据。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { runVerifyArtifacts } = require('../../../scripts/verify-artifacts');
+
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+const VERIFY_SCRIPT = path.join(REPO_ROOT, 'scripts', 'verify-artifacts.js');
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function tasksMarkdown({ profile = 'standard', taskCount = 1, extraBody = '' } = {}) {
+  const contract = [
+    '# Tasks',
+    '',
+    '## Contract Summary',
+    '',
+    'Change: REQ-900-valid-artifacts',
+    'Mode: plan',
+    `Profile: ${profile}`,
+    'Approval: approved',
+    '',
+    'Goal:',
+    '- Keep artifact verification deterministic.',
+    '',
+    'Do Not Do:',
+    '- Do not add checks outside C1-C10.',
+    '',
+    'Approved Direction:',
+    '- Verify the minimized artifact shape.',
+    '',
+    'Acceptance:',
+    '- The verifier returns stable rule ids and exit codes.',
+    '',
+    'Verification:',
+    '',
+    '```bash',
+    'npm run verify:artifacts',
+    '```',
+    '',
+    'Risk / Escalate If:',
+    '- The rule table drifts from C1-C10.',
+    ''
+  ];
+  const tasks = Array.from({ length: taskCount }, (_, index) => [
+    `- [ ] T${String(index + 1).padStart(3, '0')} validate artifacts`,
+    '  Goal: Exercise one verifier rule.',
+    '  Files: `scripts/verify-artifacts.js`',
+    '  Verification: npm run verify:artifacts',
+    `  Vertical slice: Slice ${index + 1}`,
+    ''
+  ].join('\n'));
+  return [...contract, extraBody, '## Phase 1', '', ...tasks].join('\n');
+}
+
+function seedValidChange(repoRoot, options = {}) {
+  const changeKey = options.changeKey || 'REQ-900-valid-artifacts';
+  const changeDir = path.join(repoRoot, 'devflow', 'changes', changeKey);
+  const planningDir = path.join(changeDir, 'planning');
+  fs.mkdirSync(planningDir, { recursive: true });
+  fs.writeFileSync(path.join(planningDir, 'tasks.md'), tasksMarkdown(options));
+  writeJson(path.join(planningDir, 'task-manifest.json'), {
+    changeId: changeKey,
+    createdAt: '2026-05-12T00:00:00.000Z',
+    updatedAt: '2026-05-12T00:00:00.000Z',
+    currentTaskId: null,
+    tasks: [],
+    metadata: {
+      source: 'tasks.md',
+      generatedBy: 'cc-devflow task-contract',
+      planVersion: 1
+    }
+  });
+  writeJson(path.join(changeDir, 'change-meta.json'), {
+    changeId: changeKey,
+    requirementId: changeKey,
+    goal: ['Verify artifacts'],
+    acceptance: ['Verifier passes'],
+    specReference: {
+      source: 'planning/tasks.md#contract-summary',
+      change: changeKey,
+      mode: 'plan',
+      profile: options.profile || 'standard',
+      approval: 'approved'
+    },
+    _meta: {
+      generatedBy: 'cc-devflow task-contract',
+      generatedAt: '2026-05-12T00:00:00.000Z'
+    }
+  });
+  return { changeDir, planningDir, changeKey };
+}
+
+describe('verify:artifacts', () => {
+  let repoRoot;
+
+  beforeEach(() => {
+    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-verify-artifacts-'));
+    writeJson(path.join(repoRoot, 'package.json'), {
+      name: 'verify-artifacts-fixture',
+      version: '0.0.0',
+      scripts: {
+        'verify:artifacts': 'node scripts/verify-artifacts.js'
+      }
+    });
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  const ruleCases = [
+    ['C1', 2, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'design.md'), '# legacy design\n')],
+    ['C2', 2, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'analysis.md'), '# legacy analysis\n')],
+    ['C3', 2, (ctx) => {
+      const reviewDir = path.join(ctx.changeDir, 'review');
+      fs.mkdirSync(reviewDir, { recursive: true });
+      fs.writeFileSync(path.join(reviewDir, 'cc-review-report.md'), '# legacy review\n');
+    }],
+    ['C4', 3, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'tasks.md'), '# Tasks\n\n- [ ] T001 no contract\n')],
+    ['C5', 3, (ctx) => writeJson(path.join(ctx.planningDir, 'task-manifest.json'), {
+      changeId: ctx.changeKey,
+      createdAt: '2026-05-12T00:00:00.000Z',
+      updatedAt: '2026-05-12T00:00:00.000Z',
+      currentTaskId: null,
+      tasks: [],
+      metadata: { source: 'tasks.md', generatedBy: 'manual', planVersion: 1 }
+    })],
+    ['C6', 3, (ctx) => writeJson(path.join(ctx.changeDir, 'change-meta.json'), {
+      _meta: { generatedBy: 'manual' }
+    })],
+    ['C7', 4, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'tasks.md'), tasksMarkdown({
+      profile: 'tiny',
+      taskCount: 2
+    }))],
+    ['C8', 5, (ctx) => {
+      const reviewDir = path.join(ctx.changeDir, 'review');
+      fs.mkdirSync(reviewDir, { recursive: true });
+      fs.writeFileSync(path.join(reviewDir, 'review-ledger.jsonl'), '{"event":"review-started"}\n');
+    }],
+    ['C9', 5, (ctx) => {
+      const reviewDir = path.join(ctx.changeDir, 'review');
+      fs.mkdirSync(reviewDir, { recursive: true });
+      fs.writeFileSync(path.join(reviewDir, 'report-card.json'), '{"overall":"pass"}\n');
+    }],
+    ['C10', 6, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'tasks.md'), tasksMarkdown({
+      profile: 'standard',
+      extraBody: 'x'.repeat(12000)
+    }))]
+  ];
+
+  test.each(ruleCases)('%s returns exit code %i with JSON report', async (ruleId, exitCode, mutate) => {
+    const ctx = seedValidChange(repoRoot, { changeKey: `REQ-9${ruleId.slice(1).padStart(2, '0')}-${ruleId.toLowerCase()}` });
+    mutate(ctx);
+
+    const result = await runVerifyArtifacts(repoRoot);
+
+    expect(result.code).toBe(exitCode);
+    expect(result.violations[0]).toMatchObject({ ruleId, exitCode });
+    expect(result.checks).toHaveLength(10);
+  });
+
+  test('passes a valid generated change and skips grandfathered legacy directories', async () => {
+    seedValidChange(repoRoot);
+    const legacy = seedValidChange(repoRoot, { changeKey: 'REQ-001-legacy-fallback' });
+    fs.writeFileSync(path.join(legacy.planningDir, 'design.md'), '# grandfathered design\n');
+    const manifest = JSON.parse(fs.readFileSync(path.join(legacy.planningDir, 'task-manifest.json'), 'utf8'));
+    manifest.metadata.generatedBy = 'skill:cc-plan';
+    fs.writeFileSync(path.join(legacy.planningDir, 'task-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+
+    const result = await runVerifyArtifacts(repoRoot);
+
+    expect(result).toMatchObject({ code: 0, ok: true });
+    expect(result.skippedLegacy.map((item) => item.changeKey)).toContain('REQ-001-legacy-fallback');
+  });
+
+  test('CLI prints stdout JSON and exits with the first violation code', () => {
+    const ctx = seedValidChange(repoRoot);
+    fs.writeFileSync(path.join(ctx.planningDir, 'design.md'), '# rogue design\n');
+
+    const result = spawnSync(process.execPath, [VERIFY_SCRIPT, repoRoot], { encoding: 'utf8' });
+    const report = JSON.parse(result.stdout);
+
+    expect(result.status).toBe(2);
+    expect(report.violations[0].ruleId).toBe('C1');
+  });
+
+  test('package.json exposes npm run verify:artifacts', () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+    expect(pkg.scripts['verify:artifacts']).toBe('node scripts/verify-artifacts.js');
+  });
+});

package/lib/skill-runtime/__tests__/worker-run.test.js

@@ -11,7 +11,6 @@ const {
 const {
   getRuntimeStatePath,
   getTaskManifestPath,
-  getCheckpointPath,
   getEventsPath
 } = require('../store');
 
@@ -138,7 +137,7 @@ describe('runWorkerCommand', () => {
     expect(claudeCommand).toContain('--dangerously-skip-permissions');
   });
 
-  test('runs local worker command and records only checkpoint truth by default', async () => {
+  test('runs local worker command and records only task status truth by default', async () => {
     const repoRoot = setupRepoRoot('cc-devflow-worker-run-pass-');
     const manifest = createManifest();
     writeManifest(repoRoot, manifest);
@@ -157,7 +156,6 @@ describe('runWorkerCommand', () => {
     const log = fs.readFileSync(result.sessionLogPath, 'utf8');
     const bus = fs.readFileSync(getMessageBusPath(repoRoot, 'REQ-123'), 'utf8');
     const assignment = fs.readFileSync(getWorkerAssignmentPath(repoRoot, 'REQ-123', workerId), 'utf8');
-    const checkpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T002'), 'utf8'));
     const nextManifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
     const runtimeState = JSON.parse(fs.readFileSync(getRuntimeStatePath(repoRoot, 'REQ-123'), 'utf8'));
 
@@ -167,9 +165,6 @@ describe('runWorkerCommand', () => {
     expect(log).toContain('worker-ok');
     expect(bus).toContain(`${workerId} completed T002`);
     expect(assignment).toContain('`T002` status=`completed`');
-    expect(checkpoint.status).toBe('passed');
-    expect(checkpoint.outputExcerpt).toContain('worker-ok');
-    expect(checkpoint.error).toBe('');
     expect(fs.existsSync(getEventsPath(repoRoot, 'REQ-123', 'T002'))).toBe(false);
     expect(fs.existsSync(path.join(repoRoot, 'devflow/changes/REQ-123-run-delegated-worker-command/execution/workers'))).toBe(false);
     expect(nextManifest.tasks[0].status).toBe('passed');
@@ -192,7 +187,7 @@ describe('runWorkerCommand', () => {
     expect(providerPrompt).toContain('Delegated task');
   });
 
-  test('writes failure events and checkpoint error when local command exits non-zero', async () => {
+  test('writes failure events and manifest error when local command exits non-zero', async () => {
     const repoRoot = setupRepoRoot('cc-devflow-worker-run-fail-');
     const manifest = createManifest();
     writeManifest(repoRoot, manifest);
@@ -210,7 +205,6 @@ describe('runWorkerCommand', () => {
     const log = fs.readFileSync(result.sessionLogPath, 'utf8');
     const assignment = fs.readFileSync(getWorkerAssignmentPath(repoRoot, 'REQ-123', workerId), 'utf8');
     const failedManifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
-    const checkpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T002'), 'utf8'));
     const events = fs.readFileSync(getEventsPath(repoRoot, 'REQ-123', 'T002'), 'utf8');
 
     expect(result.status).toBe('failed');
@@ -218,10 +212,9 @@ describe('runWorkerCommand', () => {
     expect(state).toContain('Status: `failed`');
     expect(log).toContain('boom');
     expect(assignment).toContain('`T002` status=`failed`');
-    expect(checkpoint.status).toBe('failed');
-    expect(checkpoint.error).toContain('boom');
     expect(events).toContain('worker_run_failed');
     expect(failedManifest.tasks[0].status).toBe('failed');
+    expect(failedManifest.tasks[0].lastError).toContain('boom');
   });
 
   test('updates only the selected task when a worker owns multiple assignments', async () => {
@@ -277,6 +270,6 @@ describe('runWorkerCommand', () => {
     });
 
     expect(fs.existsSync(path.join(repoRoot, 'blocked.txt'))).toBe(false);
-    expect(fs.existsSync(getCheckpointPath(repoRoot, 'REQ-123', 'T002'))).toBe(false);
+    expect(fs.existsSync(getEventsPath(repoRoot, 'REQ-123', 'T002'))).toBe(false);
   });
 });

package/lib/skill-runtime/__tests__/workflow-context-legacy-fallback.test.js

@@ -0,0 +1,31 @@
+/**
+ * [INPUT]: 依赖 getWorkflowContext 查询 seam、仓库内真实 legacy workflow artifacts。
+ * [OUTPUT]: 验证 legacy design.md fallback 在 compact context 中仍是一等合同入口。
+ * [POS]: REQ-003-minimize-workflow-artifacts T010 的 Red/Green 证据。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const path = require('path');
+
+const { getWorkflowContext } = require('../query');
+
+const repoRoot = path.resolve(__dirname, '../../..');
+
+describe('workflow-context legacy fallback refs', () => {
+  test.each([
+    ['REQ-002', 'REQ-002-unified-roadmap-truth']
+  ])('%s keeps design.md as the first fallback contract ref', async (changeId, changeKey) => {
+    const context = await getWorkflowContext(repoRoot, changeId, { changeKey });
+    const designRef = `devflow/changes/${changeKey}/planning/design.md#approved-direction`;
+
+    expect(context.legacyFallback).toBe(true);
+    expect(context.source.contract.path).toBe(`devflow/changes/${changeKey}/planning/design.md`);
+    expect(context.progressiveDisclosure.defaultOpen[0]).toEqual(expect.objectContaining({
+      ref: designRef,
+      reason: 'primary task contract',
+      exists: true
+    }));
+    expect(context.progressiveDisclosure.defaultOpen.every((entry) => entry.exists === true))
+      .toBe(true);
+  });
+});

package/lib/skill-runtime/__tests__/workflow-context.test.js

@@ -0,0 +1,98 @@
+/**
+ * [INPUT]: 依赖 getWorkflowContext 查询 seam、真实临时 workflow artifacts。
+ * [OUTPUT]: 验证 workflow-context 对新 tasks.md contract refs 的默认打开顺序。
+ * [POS]: REQ-003-minimize-workflow-artifacts T009 的 Red/Green 证据。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { getWorkflowContext } = require('../query');
+const { getTaskManifestPath } = require('../store');
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+describe('workflow-context contract refs', () => {
+  test.each([
+    ['REQ-130', '## Contract Summary', 'contract-summary', 'PDCA'],
+    ['FIX-130', '## Root Cause Contract', 'root-cause-contract', 'IDCA']
+  ])('primary ref is tasks.md#%s for a new change', async (
+    changeId,
+    contractHeading,
+    fragment,
+    route
+  ) => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-workflow-context-'));
+    const manifestPath = getTaskManifestPath(repoRoot, changeId);
+    const planningDir = path.dirname(manifestPath);
+    const relativeTasksPath = path.relative(repoRoot, path.join(planningDir, 'tasks.md'));
+
+    fs.mkdirSync(planningDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(planningDir, 'tasks.md'),
+      [
+        '# TASKS',
+        '',
+        contractHeading,
+        '',
+        `Change: ${changeId}`,
+        'Mode: plan',
+        'Profile: standard',
+        contractHeading.includes('Root Cause') ? 'Diagnosis: Keep root-cause truth in tasks.md.' : 'Approval: approved',
+        '',
+        '## Phase 1: Execute',
+        '',
+        '- [ ] T001 Execute new contract'
+      ].join('\n')
+    );
+    writeJson(manifestPath, {
+      changeId,
+      goal: 'Expose new contract refs',
+      createdAt: '2026-05-12T01:00:00.000Z',
+      updatedAt: '2026-05-12T01:05:00.000Z',
+      currentTaskId: 'T001',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Execute new contract',
+          type: 'OTHER',
+          phase: 1,
+          dependsOn: [],
+          run: ['npm test -- lib/skill-runtime/__tests__/workflow-context.test.js'],
+          verification: ['npm test -- lib/skill-runtime/__tests__/workflow-context.test.js'],
+          context: {
+            readFiles: ['tasks.md'],
+            commands: ['npm test -- lib/skill-runtime/__tests__/workflow-context.test.js'],
+            notes: []
+          },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'tasks.md',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    const context = await getWorkflowContext(repoRoot, changeId);
+
+    expect(context.route).toBe(route);
+    expect(context.legacyFallback).toBe(false);
+    expect(context.source.contract.path).toBe(relativeTasksPath);
+    expect(context.progressiveDisclosure.defaultOpen[0]).toEqual(expect.objectContaining({
+      ref: `${relativeTasksPath}#${fragment}`,
+      exists: true,
+      reason: 'primary task contract'
+    }));
+
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+});

package/lib/skill-runtime/artifacts.js

@@ -16,10 +16,6 @@ function getIntentArtifactsDir(repoRoot, goalId, options = {}) {
   return getChangePaths(repoRoot, goalId, options).executionDir;
 }
 
-function getIntentCheckpointsDir(repoRoot, goalId, options = {}) {
-  return getChangePaths(repoRoot, goalId, options).tasksDir;
-}
-
 function getIntentResumeIndexPath(repoRoot, goalId, options = {}) {
   return `${getChangePaths(repoRoot, goalId, options).handoffDir}/resume-index.md`;
 }
@@ -83,7 +79,6 @@ async function ensureIntentScaffold(repoRoot, goalId, options = {}) {
 module.exports = {
   getIntentDir,
   getIntentArtifactsDir,
-  getIntentCheckpointsDir,
   getIntentResumeIndexPath,
   getIntentPrBriefPath,
   getIntentStatusPath,