cc-devflow 4.5.11 → 4.5.12

package/.claude/skills/cc-check/assets/REPORT_CARD_TEMPLATE.json

@@ -1,234 +0,0 @@
-{
-  "changeId": "REQ-123",
-  "outputPolicy": {
-    "documentLanguage": ""
-  },
-  "verdict": "blocked",
-  "overall": "fail",
-  "summary": "verdict=blocked quick=1/2 strict=0/0 review=blocked",
-  "specAlignment": "blocked",
-  "specDeltaVerified": false,
-  "specSyncReady": false,
-  "runtime": {
-    "status": "blocked",
-    "failureOwnership": [
-      {
-        "errorName": "MissingSpecReviewProof",
-        "failure": "missing spec review proof",
-        "classification": "in-branch",
-        "owner": "branch",
-        "touchedByDiff": true,
-        "artifactRefs": [
-          "planning/task-manifest.json",
-          "review/report-card.json"
-        ],
-        "evidence": "planning/task-manifest.json tasks[T002].reviews.spec is empty",
-        "rescueAction": "record spec review proof for T002 or reroute to cc-do",
-        "action": "reroute-cc-do",
-        "status": "open"
-      }
-    ]
-  },
-  "claimEvidence": [
-    {
-      "claim": "tests-pass",
-      "requiredProof": "fresh test command with exit 0 and 0 failures",
-      "commandOrArtifact": "npm test -- src/feature/feature.test.ts",
-      "exitStatus": 0,
-      "keyObservation": "targeted tests passed in this run",
-      "status": "pass"
-    },
-    {
-      "claim": "requirements-met",
-      "requiredProof": "line-by-line planning/tasks.md and task-manifest.json checklist",
-      "commandOrArtifact": "planning/tasks.md + planning/task-manifest.json",
-      "exitStatus": null,
-      "keyObservation": "T002 still lacks spec review proof",
-      "status": "blocked"
-    }
-  ],
-  "qa": {
-    "status": "blocked",
-    "feedbackLoop": {
-      "status": "blocked",
-      "mode": "targeted-test",
-      "commandOrArtifact": "npm test -- src/feature/feature.test.ts",
-      "speed": "fast",
-      "determinism": "high",
-      "signalSharpness": "targeted failure would indicate the user-visible behavior regressed",
-      "reproductionRate": "not recorded",
-      "attempts": [
-        "targeted unit test"
-      ],
-      "blockedReason": "red/green reproduction is not recorded yet"
-    },
-    "behaviorEvidence": {
-      "status": "blocked",
-      "userFacingBoundary": "feature behavior",
-      "expectedBehavior": "target behavior succeeds for the user",
-      "actualBehavior": "not proven yet",
-      "reproductionSteps": [
-        "run the targeted verification command"
-      ],
-      "consistency": "not recorded",
-      "domainLanguage": [
-        "feature behavior"
-      ]
-    },
-    "regressionProof": [
-      {
-        "behavior": "original symptom",
-        "redCommand": "",
-        "redFailure": "",
-        "greenCommand": "",
-        "greenObservation": "",
-        "restoredState": false
-      }
-    ],
-    "testQuality": [
-      {
-        "area": "targeted-tests",
-        "checksRealBehavior": true,
-        "mockBoundary": "none",
-        "testOnlyProductionApi": false,
-        "status": "pass"
-      }
-    ],
-    "coverageAudit": {
-      "status": "blocked",
-      "coveragePct": null,
-      "pathMap": ["planning/tasks.md#T002"],
-      "gaps": ["T002 has no spec review proof, so the requirement cannot be marked covered"],
-      "testsAdded": [],
-      "e2eRequired": false,
-      "evalRequired": false,
-      "qualityStars": "★"
-    },
-    "browserEvidence": {
-      "status": "skipped",
-      "mode": "not-applicable",
-      "affectedRoutes": [],
-      "screenshots": [],
-      "consoleErrors": [],
-      "healthScore": null,
-      "issues": [],
-      "skipReason": "template example is not a UI browser QA scenario"
-    },
-    "humanUat": {
-      "status": "skipped",
-      "required": false,
-      "scenario": "",
-      "tester": "",
-      "evidence": [],
-      "failure": "",
-      "reroute": "none",
-      "skipReason": "not required for this template scenario"
-    },
-    "architectureFollowUps": [
-      {
-        "summary": "Add the missing public test seam before widening coverage",
-        "currentBehavior": "review proof depends on task metadata instead of a direct behavior seam",
-        "desiredBehavior": "tests verify the behavior through a stable public interface",
-        "keyInterfaces": [
-          "feature public API"
-        ],
-        "acceptanceCriteria": [
-          "target behavior can be reproduced without private implementation hooks"
-        ],
-        "outOfScope": [
-          "rewriting unrelated modules"
-        ],
-        "status": "deferred-minor"
-      }
-    ],
-    "tddException": null
-  },
-  "quickGates": [
-    {
-      "name": "targeted-tests",
-      "status": "pass",
-      "command": "npm test -- src/feature/feature.test.ts",
-      "summary": "targeted tests passed"
-    },
-    {
-      "name": "review-proof",
-      "status": "blocked",
-      "command": "review artifacts",
-      "summary": "missing spec review proof for T002"
-    }
-  ],
-  "strictGates": [],
-  "review": {
-    "status": "blocked",
-    "summary": "Task review evidence is incomplete",
-    "details": "T002 is implemented, but the requirement still lacks spec review proof required by the gate.",
-    "freshness": {
-      "status": "unknown",
-      "reviewedCommit": "",
-      "currentCommit": "",
-      "commitsSinceReview": null,
-      "staleReason": "review range is not recorded yet"
-    },
-    "qualityScore": null,
-    "specialistReviews": [
-      {
-        "name": "testing",
-        "status": "blocked",
-        "required": true,
-        "summary": "testing facet cannot pass while task review proof is missing",
-        "skipReason": "",
-        "findings": []
-      }
-    ],
-    "taskReviews": {
-      "status": "blocked",
-      "required": true,
-      "summary": "T002 has no spec review record yet",
-      "reviewPacket": {
-        "baseSha": "",
-        "headSha": "",
-        "requirements": "planning/tasks.md#T002",
-        "implemented": "implementation report for T002",
-        "reviewerContext": "task spec and changed files"
-      },
-      "reviewers": [],
-      "findings": [
-        {
-          "severity": "important",
-          "confidence": "high",
-          "source": "task-review",
-          "summary": "T002 spec review proof is missing",
-          "evidence": "planning/task-manifest.json tasks[T002].reviews.spec is empty",
-          "action": "reroute-cc-do",
-          "rescueAction": "record spec review proof for T002 or return to cc-do",
-          "triageStatus": "clarification-needed",
-          "confidenceScore": 9,
-          "fingerprint": "task-review:T002:missing-spec-review",
-          "displayTier": "blocking",
-          "suppressionReason": null
-        }
-      ]
-    },
-    "diffReview": {
-      "status": "skipped",
-      "required": false,
-      "summary": "",
-      "reviewPacket": {
-        "baseSha": "",
-        "headSha": "",
-        "requirements": "planning/design.md",
-        "implemented": "",
-        "reviewerContext": ""
-      },
-      "reviewers": [],
-      "findings": []
-    },
-    "findings": []
-  },
-  "blockingFindings": [
-    "review: missing spec review proof for T002"
-  ],
-  "gaps": [],
-  "reroute": "cc-do",
-  "timestamp": "2026-04-15T12:00:00.000Z"
-}

package/.claude/skills/cc-check/scripts/render-report-card.js

@@ -1,438 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-
-function usage() {
-  console.error(
-    'Usage: render-report-card.js --change-id REQ-123 --manifest task-manifest.json --quick quick.json --strict strict.json --review review.json'
-  );
-}
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-function parseArgs(argv) {
-  const args = {
-    changeId: '',
-    manifest: '',
-    quick: '',
-    strict: '',
-    review: '',
-    timestamp: ''
-  };
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === '--change-id') {
-      args.changeId = argv[index + 1] || '';
-      index += 1;
-      continue;
-    }
-    if (arg === '--manifest') {
-      args.manifest = argv[index + 1] || '';
-      index += 1;
-      continue;
-    }
-    if (arg === '--quick') {
-      args.quick = argv[index + 1] || '';
-      index += 1;
-      continue;
-    }
-    if (arg === '--strict') {
-      args.strict = argv[index + 1] || '';
-      index += 1;
-      continue;
-    }
-    if (arg === '--review') {
-      args.review = argv[index + 1] || '';
-      index += 1;
-      continue;
-    }
-    if (arg === '--timestamp') {
-      args.timestamp = argv[index + 1] || '';
-      index += 1;
-      continue;
-    }
-  }
-
-  return args;
-}
-
-function deriveVerdict(manifest, quickGates, strictGates, review) {
-  if ((manifest.tasks || []).some((task) => task.status === 'failed')) {
-    return 'fail';
-  }
-
-  if ([...quickGates, ...strictGates].some((gate) => gate.status === 'fail')) {
-    return 'fail';
-  }
-
-  if ([...quickGates, ...strictGates].some((gate) => ['blocked', 'pending'].includes(gate.status))) {
-    return 'blocked';
-  }
-
-  if (review.qa?.status === 'fail') {
-    return 'fail';
-  }
-
-  if (['blocked', 'pending'].includes(review.qa?.status)) {
-    return 'blocked';
-  }
-
-  if (['fail'].includes(review.qa?.feedbackLoop?.status)) {
-    return 'fail';
-  }
-
-  if (['blocked', 'pending'].includes(review.qa?.feedbackLoop?.status)) {
-    return 'blocked';
-  }
-
-  if (['fail'].includes(review.qa?.behaviorEvidence?.status)) {
-    return 'fail';
-  }
-
-  if (['blocked', 'pending'].includes(review.qa?.behaviorEvidence?.status)) {
-    return 'blocked';
-  }
-
-  if (review.status === 'blocked') {
-    return 'blocked';
-  }
-
-  if (review.status === 'fail') {
-    return 'fail';
-  }
-
-  const freshness = buildReviewFreshness(review).status;
-  if (review.status === 'pass' && !['fresh', 'not-applicable'].includes(freshness)) {
-    return 'blocked';
-  }
-
-  const openOwnedFailures = (review.runtime?.failureOwnership || []).some((item) => {
-    const classification = item.classification || '';
-    const status = item.status || 'open';
-    return ['in-branch', 'ambiguous'].includes(classification) && !['resolved', 'closed'].includes(status);
-  });
-  if (openOwnedFailures) {
-    return 'blocked';
-  }
-
-  return 'pass';
-}
-
-function deriveReroute({ verdict, review, manifest, blockingFindings }) {
-  if (verdict === 'pass') {
-    return 'none';
-  }
-
-  const taskFailures = (manifest.tasks || []).some((task) => task.status === 'failed');
-  if (taskFailures) {
-    return 'cc-do';
-  }
-
-  const rerouteSignals = [
-    review.summary || '',
-    review.details || '',
-    ...(blockingFindings || [])
-  ].join(' ').toLowerCase();
-
-  if (/(root cause|repro|debug|investigat|regression)/.test(rerouteSignals)) {
-    return 'cc-investigate';
-  }
-
-  if (/(design|scope|plan|planning|requirement|contract)/.test(rerouteSignals)) {
-    return 'cc-plan';
-  }
-
-  return 'cc-do';
-}
-
-function buildSummary({ quickGates, strictGates, review, verdict }) {
-  const gateSummary = (gates) => `${gates.filter((gate) => gate.status === 'pass').length}/${gates.length}`;
-  return [
-    `verdict=${verdict}`,
-    `quick=${gateSummary(quickGates)}`,
-    `strict=${gateSummary(strictGates)}`,
-    `review=${review.status}`
-  ].join(' ');
-}
-
-function claimFromGate(gate) {
-  const name = String(gate.name || '').toLowerCase();
-  if (/test|spec/.test(name)) {
-    return 'tests-pass';
-  }
-  if (/lint/.test(name)) {
-    return 'lint-clean';
-  }
-  if (/type/.test(name)) {
-    return 'typecheck-clean';
-  }
-  if (/build|compile/.test(name)) {
-    return 'build-succeeds';
-  }
-  return `gate-${gate.name || 'unknown'}`;
-}
-
-function isTaskComplete(task) {
-  const status = String(task?.status || (task?.completed ? 'completed' : 'pending')).toLowerCase();
-  return ['passed', 'done', 'completed', 'verified'].includes(status);
-}
-
-function buildClaimEvidence({ manifest, quickGates, strictGates, review }) {
-  const gateClaims = [...quickGates, ...strictGates].map((gate) => ({
-    claim: claimFromGate(gate),
-    requiredProof: 'fresh command output with exit status and key observation',
-    commandOrArtifact: gate.command || gate.name || '',
-    exitStatus: gate.exitStatus ?? null,
-    keyObservation: gate.summary || gate.details || '',
-    status: gate.status || 'blocked'
-  }));
-
-  const openTasks = (manifest.tasks || []).filter((task) => !isTaskComplete(task));
-  gateClaims.push({
-    claim: 'requirements-met',
-    requiredProof: 'line-by-line planning/tasks.md and task-manifest.json checklist',
-    commandOrArtifact: 'planning/tasks.md + planning/task-manifest.json',
-    exitStatus: null,
-    keyObservation: openTasks.length === 0 ? 'no open task gaps recorded' : `${openTasks.length} open task gaps recorded`,
-    status: openTasks.length === 0 && review.status === 'pass' ? 'pass' : 'blocked'
-  });
-
-  return [...(review.claimEvidence || []), ...gateClaims];
-}
-
-function buildQa(review) {
-  return {
-    status: review.qa?.status || 'skipped',
-    feedbackLoop: review.qa?.feedbackLoop || {
-      status: 'skipped',
-      mode: 'not-applicable',
-      commandOrArtifact: '',
-      speed: '',
-      determinism: '',
-      signalSharpness: '',
-      reproductionRate: '',
-      attempts: [],
-      blockedReason: 'not recorded'
-    },
-    behaviorEvidence: review.qa?.behaviorEvidence || {
-      status: 'skipped',
-      userFacingBoundary: '',
-      expectedBehavior: '',
-      actualBehavior: '',
-      reproductionSteps: [],
-      consistency: '',
-      domainLanguage: []
-    },
-    regressionProof: review.qa?.regressionProof || [],
-    testQuality: review.qa?.testQuality || [],
-    coverageAudit: review.qa?.coverageAudit || {
-      status: 'skipped',
-      coveragePct: null,
-      pathMap: [],
-      gaps: [],
-      testsAdded: [],
-      e2eRequired: false,
-      evalRequired: false,
-      qualityStars: ''
-    },
-    browserEvidence: review.qa?.browserEvidence || {
-      status: 'skipped',
-      mode: 'not-applicable',
-      affectedRoutes: [],
-      screenshots: [],
-      consoleErrors: [],
-      healthScore: null,
-      issues: [],
-      skipReason: 'not recorded'
-    },
-    architectureFollowUps: review.qa?.architectureFollowUps || [],
-    tddException: review.qa?.tddException || null
-  };
-}
-
-function buildRuntime(review) {
-  const failureOwnership = review.runtime?.failureOwnership || [];
-  const hasOpenOwnedFailure = failureOwnership.some((item) => {
-    const classification = item.classification || '';
-    const status = item.status || 'open';
-    return ['in-branch', 'ambiguous'].includes(classification) && !['resolved', 'closed'].includes(status);
-  });
-
-  return {
-    status: review.runtime?.status || (hasOpenOwnedFailure ? 'blocked' : 'pass'),
-    failureOwnership
-  };
-}
-
-function firstReviewHead(review) {
-  return [
-    review.taskReviews?.reviewPacket?.headSha,
-    review.diffReview?.reviewPacket?.headSha
-  ].find((value) => typeof value === 'string' && value.length > 0) || '';
-}
-
-function buildReviewFreshness(review) {
-  if (review.freshness) {
-    return review.freshness;
-  }
-
-  const headSha = firstReviewHead(review);
-  if (!headSha) {
-    return {
-      status: 'unknown',
-      reviewedCommit: '',
-      currentCommit: '',
-      commitsSinceReview: null,
-      staleReason: 'review headSha is not recorded'
-    };
-  }
-
-  return {
-    status: 'fresh',
-    reviewedCommit: headSha,
-    currentCommit: headSha,
-    commitsSinceReview: 0,
-    staleReason: ''
-  };
-}
-
-function buildReview(review) {
-  return {
-    ...review,
-    freshness: buildReviewFreshness(review),
-    qualityScore: review.qualityScore ?? null,
-    specialistReviews: review.specialistReviews || []
-  };
-}
-
-function isFindingOpen(item) {
-  const status = item.status || item.triageStatus || '';
-  return !['resolved', 'accepted', 'informational', 'accepted-fixed', 'rejected-with-evidence', 'deferred-minor'].includes(status);
-}
-
-function summarizeOpenReviewFindings(findings = []) {
-  return findings
-    .filter(isFindingOpen)
-    .map((item) => `${item.source || 'review'}: ${item.summary || item.evidence || 'open finding'}`);
-}
-
-function collectBlockingFindings({ manifest, quickGates, strictGates, review }) {
-  const findings = [];
-
-  for (const task of manifest.tasks || []) {
-    if (task.status === 'failed') {
-      findings.push(`${task.id}: ${task.lastError || 'task failed'}`);
-    }
-  }
-
-  for (const gate of [...quickGates, ...strictGates]) {
-    if (['fail', 'blocked', 'pending'].includes(gate.status)) {
-      findings.push(`${gate.name}: ${gate.details || gate.summary || gate.status}`);
-    }
-  }
-
-  if (review.status === 'blocked' || review.status === 'fail') {
-    findings.push(`review: ${review.summary || review.details || review.status}`);
-  }
-
-  return findings.concat(summarizeOpenReviewFindings(review.findings || []));
-}
-
-function deriveSpecSignals(manifest, verdict, review) {
-  const spec = manifest.spec || {};
-  const hasSpec =
-    Boolean(spec.primaryCapability) ||
-    (Array.isArray(spec.secondaryCapabilities) && spec.secondaryCapabilities.length > 0) ||
-    (Array.isArray(spec.specFiles) && spec.specFiles.length > 0);
-
-  if (!hasSpec || review.status === 'blocked') {
-    return {
-      specAlignment: 'blocked',
-      specDeltaVerified: false,
-      specSyncReady: false
-    };
-  }
-
-  if (verdict === 'fail') {
-    return {
-      specAlignment: 'fail',
-      specDeltaVerified: false,
-      specSyncReady: false
-    };
-  }
-
-  return {
-    specAlignment: 'pass',
-    specDeltaVerified: true,
-    specSyncReady: true
-  };
-}
-
-function main() {
-  const args = parseArgs(process.argv.slice(2));
-  if (!args.changeId || !args.manifest || !args.quick || !args.strict || !args.review) {
-    usage();
-    process.exit(1);
-  }
-
-  const manifest = readJson(args.manifest);
-  const quickGates = readJson(args.quick);
-  const strictGates = readJson(args.strict);
-  const review = readJson(args.review);
-
-  const blockingFindings = collectBlockingFindings({
-    manifest,
-    quickGates,
-    strictGates,
-    review
-  });
-  const verdict = deriveVerdict(manifest, quickGates, strictGates, review);
-  const reroute = deriveReroute({
-    verdict,
-    review,
-    manifest,
-    blockingFindings
-  });
-  const specSignals = deriveSpecSignals(manifest, verdict, review);
-  const claimEvidence = buildClaimEvidence({
-    manifest,
-    quickGates,
-    strictGates,
-    review
-  });
-  const runtime = buildRuntime(review);
-  const qa = buildQa(review);
-  const reviewReport = buildReview(review);
-
-  const report = {
-    changeId: args.changeId,
-    verdict,
-    overall: verdict === 'pass' ? 'pass' : 'fail',
-    summary: buildSummary({
-      quickGates,
-      strictGates,
-      review,
-      verdict
-    }),
-    specAlignment: specSignals.specAlignment,
-    specDeltaVerified: specSignals.specDeltaVerified,
-    specSyncReady: specSignals.specSyncReady,
-    runtime,
-    claimEvidence,
-    qa,
-    quickGates,
-    strictGates,
-    review: reviewReport,
-    blockingFindings,
-    gaps: manifest.spec?.newGaps || [],
-    reroute,
-    timestamp: args.timestamp || new Date().toISOString()
-  };
-
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-}
-
-main();