cc-devflow 4.5.9 → 4.5.10

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

@@ -6,6 +6,7 @@ const {
   getFullState,
   getNextTask,
   getProgress,
+  getWorkflowContext,
   listQueryIds,
   runQuery
 } = require('../query');
@@ -288,6 +289,386 @@ describe('query helpers', () => {
     expect(next.id).toBe('T002');
   });
 
+  test('returns compact workflow context for the current ready task', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-context-'));
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-126');
+    const planningDir = path.dirname(manifestPath);
+    const changeDir = path.dirname(planningDir);
+
+    fs.mkdirSync(planningDir, { recursive: true });
+    fs.writeFileSync(path.join(planningDir, 'design.md'), '# Design\n');
+    fs.writeFileSync(path.join(planningDir, 'tasks.md'), '# Tasks\n');
+    writeJson(path.join(changeDir, 'change-meta.json'), {
+      spec: {
+        primaryCapability: 'cap-compact-context',
+        syncStatus: 'planned'
+      }
+    });
+    writeJson(manifestPath, {
+      changeId: 'REQ-126',
+      goal: 'Expose compact workflow context',
+      createdAt: '2026-05-12T01:00:00.000Z',
+      updatedAt: '2026-05-12T01:05:00.000Z',
+      currentTaskId: 'T002',
+      planningMeta: {
+        reqPlanSkillVersion: '3.8.8'
+      },
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Completed test task',
+          type: 'TEST',
+          phase: 1,
+          dependsOn: [],
+          touches: ['src/feature.test.ts'],
+          files: ['src/feature.test.ts'],
+          run: ['npm test -- src/feature.test.ts'],
+          checks: [],
+          acceptance: [],
+          verification: ['npm test -- src/feature.test.ts'],
+          evidence: ['red output'],
+          context: { readFiles: ['planning/design.md'], commands: ['npm test -- src/feature.test.ts'], notes: [] },
+          status: 'passed',
+          attempts: 1,
+          maxRetries: 1
+        },
+        {
+          id: 'T002',
+          title: 'Implement compact context',
+          type: 'IMPL',
+          phase: 1,
+          dependsOn: ['T001'],
+          touches: ['lib/skill-runtime/query.js'],
+          files: ['lib/skill-runtime/query.js'],
+          run: ['npm test -- lib/skill-runtime/__tests__/query.test.js'],
+          checks: [],
+          acceptance: [],
+          verification: ['npm test -- lib/skill-runtime/__tests__/query.test.js'],
+          evidence: ['green output'],
+          context: {
+            readFiles: ['design.md', 'tasks.md', 'change-meta.json', 'lib/skill-runtime/query.js'],
+            commands: ['npm test -- lib/skill-runtime/__tests__/query.test.js'],
+            notes: ['Read the context index before opening deep docs']
+          },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 2
+      }
+    });
+
+    const context = await getWorkflowContext(repoRoot, 'REQ-126');
+
+    expect(context.nextAction).toMatchObject({
+      skill: 'cc-do',
+      action: 'execute-current-task',
+      taskId: 'T002'
+    });
+    expect(context.currentTask).toMatchObject({
+      id: 'T002',
+      context: {
+        readFiles: expect.arrayContaining(['design.md', 'tasks.md', 'change-meta.json', 'lib/skill-runtime/query.js'])
+      }
+    });
+    expect(context.progressiveDisclosure).toMatchObject({
+      mode: 'compact-first',
+      rule: expect.stringContaining('context index'),
+      packetOnly: {
+        contractDigest: expect.any(String),
+        manifestDigest: expect.any(String),
+        currentTaskDigest: expect.any(String),
+        evidenceDigest: expect.any(String),
+        mustNotForgetDigest: expect.any(String)
+      }
+    });
+    expect(context.source.manifest).toMatchObject({
+      path: expect.stringContaining('planning/task-manifest.json'),
+      hash: expect.stringMatching(/^sha256:/)
+    });
+    expect(context.progressiveDisclosure.sourceHashes).toEqual(expect.objectContaining({
+      [context.source.manifest.path]: expect.stringMatching(/^sha256:/)
+    }));
+    expect(context.progressiveDisclosure.mustNotForget).toMatchObject({
+      goal: {
+        value: 'Expose compact workflow context',
+        source: {
+          ref: expect.stringContaining('planning/task-manifest.json#/goal'),
+          hash: expect.stringMatching(/^sha256:/)
+        }
+      },
+      nonNegotiables: expect.arrayContaining([
+        expect.objectContaining({
+          value: expect.stringContaining('read-only'),
+          source: expect.objectContaining({ ref: expect.any(String) })
+        })
+      ]),
+      acceptanceGates: expect.arrayContaining([
+        expect.objectContaining({
+          value: 'npm test -- lib/skill-runtime/__tests__/query.test.js',
+          source: expect.objectContaining({ ref: expect.stringContaining('planning/task-manifest.json#/tasks/T002') })
+        })
+      ])
+    });
+    expect(context.progressiveDisclosure.defaultOpen).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        ref: expect.stringContaining('planning/design.md#design'),
+        reason: 'primary task contract',
+        exists: true,
+        sourceHash: expect.stringMatching(/^sha256:/)
+      }),
+      expect.objectContaining({
+        ref: expect.stringContaining('planning/task-manifest.json#/tasks/T002'),
+        reason: 'current task source of truth',
+        sourceHash: expect.stringMatching(/^sha256:/)
+      }),
+      expect.objectContaining({
+        ref: expect.stringContaining('change-meta.json#/spec')
+      })
+    ]));
+    expect(context.progressiveDisclosure.defaultOpen.every((entry) => entry.exists === true)).toBe(true);
+    expect(context.progressiveDisclosure.defaultRead).toBeUndefined();
+    expect(context.progressiveDisclosure.deepOpen).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        when: 'scope_or_contract_uncertain',
+        conditions: expect.arrayContaining(['confidence.scope < 0.85']),
+        refs: expect.arrayContaining([
+          expect.objectContaining({ ref: expect.stringContaining('planning/design.md') })
+        ])
+      }),
+      expect.objectContaining({
+        when: 'implementation_details_needed',
+        refs: expect.arrayContaining([
+          expect.objectContaining({ ref: 'lib/skill-runtime/query.js' })
+        ])
+      })
+    ]));
+    expect(context.progressiveDisclosure.defaultOpen).not.toEqual(expect.arrayContaining([
+      'design.md',
+      'tasks.md',
+      'change-meta.json'
+    ]));
+    expect(context.progressiveDisclosure.commandsToTrust).toContain('npm test -- lib/skill-runtime/__tests__/query.test.js');
+    expect(context.progressiveDisclosure.openWhen).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        trigger: expect.stringContaining('all tasks are complete'),
+        conditions: expect.arrayContaining(['nextAction.skill == cc-act'])
+      })
+    ]));
+    expect(context.planningMeta).toMatchObject({
+      reqPlanSkillVersion: '3.8.8',
+      sourceCapability: 'cap-compact-context',
+      specSyncStatus: 'planned'
+    });
+  });
+
+  test('routes compact workflow context through check and act after execution', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-terminal-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-127'), {
+      changeId: 'REQ-127',
+      goal: 'Expose terminal workflow routing',
+      createdAt: '2026-05-12T01:00:00.000Z',
+      updatedAt: '2026-05-12T01:05:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          status: 'passed',
+          verification: ['npm test -- final.test.js'],
+          context: {
+            commands: ['npm test -- final.test.js']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-127')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-check',
+        action: 'build-fresh-verdict'
+      },
+      progressiveDisclosure: {
+        commandsToTrust: ['npm test -- final.test.js']
+      }
+    });
+
+    writeJson(getReportCardPath(repoRoot, 'REQ-127'), {
+      changeId: 'REQ-127',
+      verdict: 'pass',
+      overall: 'pass',
+      reroute: 'none',
+      specSyncReady: false,
+      blockingFindings: [],
+      timestamp: '2026-05-12T01:10:00.000Z'
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-127')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-check',
+        action: 'build-fresh-verdict',
+        blockers: expect.arrayContaining(['specSyncReady is not true'])
+      }
+    });
+
+    writeJson(getReportCardPath(repoRoot, 'REQ-127'), {
+      changeId: 'REQ-127',
+      verdict: 'pass',
+      overall: 'pass',
+      reroute: 'none',
+      specSyncReady: true,
+      blockingFindings: [],
+      timestamp: '2026-05-12T01:11:00.000Z'
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-127')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-act',
+        action: 'ship-or-handoff'
+      }
+    });
+  });
+
+  test('resumes current running task before selecting another ready task', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-resume-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-130'), {
+      changeId: 'REQ-130',
+      currentTaskId: 'T002',
+      tasks: [
+        { id: 'T001', status: 'passed' },
+        {
+          id: 'T002',
+          status: 'running',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/current.test.ts'],
+          context: {
+            commands: ['npm test -- src/current.test.ts']
+          }
+        },
+        {
+          id: 'T003',
+          status: 'pending',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/ready.test.ts'],
+          context: {
+            commands: ['npm test -- src/ready.test.ts']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-130')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-do',
+        action: 'resume-current-task',
+        taskId: 'T002'
+      },
+      currentTask: {
+        id: 'T002',
+        status: 'running'
+      }
+    });
+  });
+
+  test('resumes inferred running task before selecting ready task when currentTaskId is missing', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-inferred-resume-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-132'), {
+      changeId: 'REQ-132',
+      tasks: [
+        { id: 'T001', status: 'passed' },
+        {
+          id: 'T002',
+          status: 'running',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/current.test.ts'],
+          context: {
+            commands: ['npm test -- src/current.test.ts']
+          }
+        },
+        {
+          id: 'T003',
+          status: 'pending',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/ready.test.ts'],
+          context: {
+            commands: ['npm test -- src/ready.test.ts']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-132')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-do',
+        action: 'resume-current-task',
+        taskId: 'T002'
+      },
+      currentTask: {
+        id: 'T002',
+        status: 'running'
+      }
+    });
+  });
+
+  test('reports missing verification commands instead of trusting the query command', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-missing-commands-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-131'), {
+      changeId: 'REQ-131',
+      currentTaskId: 'T001',
+      tasks: [
+        {
+          id: 'T001',
+          status: 'pending',
+          context: {
+            readFiles: ['design.md']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-131')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-plan',
+        action: 'repair-task-verification',
+        taskId: 'T001'
+      },
+      progressiveDisclosure: {
+        commandsToTrust: [],
+        missingVerificationCommands: true,
+        manifestIssue: 'current task has no executable verification command',
+        failClosed: expect.arrayContaining([
+          expect.stringContaining('verification command is missing')
+        ])
+      }
+    });
+  });
+
   test('dispatches typed query ids with trace metadata', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-registry-'));
 
@@ -321,7 +702,7 @@ describe('query helpers', () => {
       }
     });
 
-    expect(listQueryIds()).toEqual(expect.arrayContaining(['full-state', 'next-task', 'progress']));
+    expect(listQueryIds()).toEqual(expect.arrayContaining(['full-state', 'next-task', 'progress', 'workflow-context']));
   });
 
   test('requires a full change key when duplicate local numbers exist', async () => {
@@ -354,7 +735,7 @@ describe('query helpers', () => {
       },
       trace: {
         event: 'query.progress.failed',
-        nextAction: 'inspect-runtime-artifacts'
+        nextAction: 'inspect-workflow-artifacts'
       }
     });
 
@@ -381,7 +762,7 @@ describe('query helpers', () => {
       queryId: 'unknown-query',
       error: {
         name: 'UnknownQueryError',
-        rescueAction: 'use one of: full-state, next-task, progress, ship-readiness'
+        rescueAction: 'use one of: full-state, next-task, progress, ship-readiness, workflow-context'
       },
       trace: {
         nextAction: 'choose-supported-query'
@@ -400,11 +781,11 @@ describe('query helpers', () => {
         artifactRefs: [
           expect.stringContaining('task-manifest.json')
         ],
-        rescueAction: 'create required runtime artifacts before running this query'
+        rescueAction: 'create required workflow artifacts before running this query'
       },
       trace: {
         event: 'query.progress.failed',
-        nextAction: 'create required runtime artifacts before running this query'
+        nextAction: 'create required workflow artifacts before running this query'
       }
     });
   });
@@ -423,11 +804,11 @@ describe('query helpers', () => {
         artifactRefs: [
           expect.stringContaining('task-manifest.json')
         ],
-        rescueAction: 'repair or regenerate the invalid runtime artifact before running this query'
+        rescueAction: 'repair or regenerate the invalid workflow artifact before running this query'
       },
       trace: {
         event: 'query.progress.failed',
-        nextAction: 'repair or regenerate the invalid runtime artifact before running this query'
+        nextAction: 'repair or regenerate the invalid workflow artifact before running this query'
       }
     });
   });

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

@@ -0,0 +1,148 @@
+/**
+ * [INPUT]: 依赖 runReviewSuite、临时 devflow review artifacts。
+ * [OUTPUT]: 验证 cc-check review 读取 review-findings.json 优先并按 legacy 层级 fallback。
+ * [POS]: REQ-003-minimize-workflow-artifacts T015 的 Red/Green 证据。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { runReviewSuite } = require('../review');
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeText(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, value);
+}
+
+function makeReviewRoot(changeId, changeKey) {
+  const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-review-check-'));
+  const reviewDir = path.join(repoRoot, 'devflow', 'changes', changeKey, 'review');
+  fs.mkdirSync(reviewDir, { recursive: true });
+  return { repoRoot, reviewDir, changeId, changeKey };
+}
+
+function findingsDoc(overrides = {}) {
+  return {
+    schema: 'review-findings.v2',
+    change: 'REQ-140-review-records',
+    reviewId: 'RVW-20260512-001',
+    headSha: 'def456',
+    freshness: {
+      status: 'fresh',
+      reviewedCommit: 'def456',
+      currentCommit: 'def456',
+      commitsSinceReview: 0
+    },
+    summary: {
+      status: 'findings',
+      blockingCount: 1,
+      warningCount: 0,
+      next: 'cc-do'
+    },
+    findings: [
+      {
+        id: 'F001',
+        severity: 'important',
+        confidence: 8,
+        displayTier: 'blocking',
+        fingerprint: 'sha256:f001',
+        scope: 'inside current requirement blast radius',
+        path: 'lib/skill-runtime/review.js',
+        evidence: 'review records should be consumed before legacy report text',
+        recommendation: 'read review-findings.json first',
+        route: 'cc-do'
+      }
+    ],
+    ...overrides
+  };
+}
+
+async function runReviewCase(files) {
+  const ctx = makeReviewRoot('REQ-140', 'REQ-140-review-records');
+  if (files.findings) {
+    writeJson(path.join(ctx.reviewDir, 'review-findings.json'), files.findings);
+  }
+  if (files.ledger) {
+    writeText(path.join(ctx.reviewDir, 'review-ledger.jsonl'), files.ledger);
+  }
+  if (files.legacyReport) {
+    writeText(path.join(ctx.reviewDir, 'cc-review-report.md'), files.legacyReport);
+  }
+
+  const review = await runReviewSuite({
+    repoRoot: ctx.repoRoot,
+    changeId: ctx.changeId,
+    manifest: { tasks: [] },
+    strict: false,
+    skipReview: true
+  });
+  fs.rmSync(ctx.repoRoot, { recursive: true, force: true });
+  return review;
+}
+
+describe('cc-check review record fallback', () => {
+  test('reads review-findings.json before ledger or legacy report', async () => {
+    const review = await runReviewCase({
+      findings: findingsDoc(),
+      ledger: '{"schema":"review-ledger.v2","change":"REQ-140-review-records","reviewId":"RVW-20260512-002","createdAt":"2026-05-12T00:00:00.000Z","createdBy":"cc-devflow-cli","event":"review-closed","status":"clean","blockingCount":0,"warningCount":0,"next":"cc-check"}\n',
+      legacyReport: '# Legacy Report\n'
+    });
+
+    expect(review.recordReview).toMatchObject({
+      source: 'review-findings.json',
+      status: 'fail',
+      freshness: { status: 'fresh' }
+    });
+    expect(review.findings[0]).toMatchObject({
+      id: 'F001',
+      source: 'review-records',
+      severity: 'important',
+      displayTier: 'blocking'
+    });
+  });
+
+  test('falls back to ledger tail when findings doc is missing', async () => {
+    const review = await runReviewCase({
+      ledger: [
+        '{"schema":"review-ledger.v2","change":"REQ-140-review-records","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":[]}',
+        '{"schema":"review-ledger.v2","change":"REQ-140-review-records","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')
+    });
+
+    expect(review.recordReview).toMatchObject({
+      source: 'review-ledger.jsonl',
+      status: 'pass',
+      summary: expect.stringContaining('review ledger')
+    });
+  });
+
+  test('falls back to legacy cc-review-report.md with unknown freshness', async () => {
+    const review = await runReviewCase({
+      legacyReport: '# Legacy Review\n\nNo blocking findings.\n'
+    });
+
+    expect(review.recordReview).toMatchObject({
+      source: 'cc-review-report.md',
+      status: 'pass',
+      freshness: { status: 'unknown' }
+    });
+  });
+
+  test('blocks when all review records are missing', async () => {
+    const review = await runReviewCase({});
+
+    expect(review.status).toBe('blocked');
+    expect(review.recordReview).toMatchObject({
+      source: 'review-records',
+      status: 'blocked',
+      summary: expect.stringContaining('review-missing')
+    });
+  });
+});