cclaw-cli 7.0.5 → 7.1.0

package/dist/tdd-verification-evidence.js

@@ -1,13 +1,86 @@
+import { execFile } from "node:child_process";
 import path from "node:path";
+import { promisify } from "node:util";
+import { readConfig, resolveTddCommitMode } from "./config.js";
+import { readDelegationLedger } from "./delegation.js";
 import { exists } from "./fs-utils.js";
+const execFileAsync = promisify(execFile);
 export const TEST_COMMAND_HINT_PATTERN = /\b(?:npm test|npm run test(?::[\w:-]+)?|pnpm test|pnpm [\w:-]*test[\w:-]*|yarn test|yarn [\w:-]*test[\w:-]*|bun test|bun run test(?::[\w:-]+)?|vitest|jest|pytest|go test|cargo test|mvn test|gradle test|\.\/gradlew test|dotnet test)\b/iu;
 export const SHA_WITH_LABEL_PATTERN = /\b(?:sha|commit)(?:\s*[:=]|\s+)\s*[0-9a-f]{7,40}\b/iu;
 export const PASS_STATUS_PATTERN = /\b(?:pass|passed|green|ok)\b/iu;
 export const NO_VCS_ATTESTATION_PATTERN = /\b(?:no[-_ ]?vcs|no git|not a git repo|vcs\s*[:=]\s*none)\b/iu;
 export const NO_VCS_HASH_PATTERN = /\b(?:content|artifact)[-_ ]?hash\s*[:=]\s*(?:sha256:)?[0-9a-f]{16,64}\b|\bsha256\s*[:=]\s*[0-9a-f]{16,64}\b/iu;
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function hasRefactorCoverage(entries) {
+    const phases = new Set(entries
+        .filter((e) => e.status === "completed" && typeof e.phase === "string")
+        .map((e) => e.phase));
+    if (phases.has("refactor") || phases.has("refactor-deferred")) {
+        return true;
+    }
+    const greenWithOutcome = entries.find((entry) => entry.status === "completed" &&
+        entry.phase === "green" &&
+        entry.refactorOutcome &&
+        (entry.refactorOutcome.mode === "inline" || entry.refactorOutcome.mode === "deferred"));
+    if (!greenWithOutcome?.refactorOutcome)
+        return false;
+    if (greenWithOutcome.refactorOutcome.mode === "inline")
+        return true;
+    const rationale = greenWithOutcome.refactorOutcome.rationale;
+    if (typeof rationale === "string" && rationale.trim().length > 0)
+        return true;
+    if (!Array.isArray(greenWithOutcome.evidenceRefs))
+        return false;
+    return greenWithOutcome.evidenceRefs.some((ref) => typeof ref === "string" && ref.trim().length > 0);
+}
+function collectClosedSlices(entries, runId) {
+    const bySlice = new Map();
+    for (const entry of entries) {
+        if (entry.runId !== runId)
+            continue;
+        if (entry.stage !== "tdd")
+            continue;
+        if (entry.status !== "completed")
+            continue;
+        if (typeof entry.sliceId !== "string" || entry.sliceId.length === 0)
+            continue;
+        if (typeof entry.spanId !== "string" || entry.spanId.length === 0)
+            continue;
+        const bySpan = bySlice.get(entry.sliceId) ?? new Map();
+        const rows = bySpan.get(entry.spanId) ?? [];
+        rows.push(entry);
+        bySpan.set(entry.spanId, rows);
+        bySlice.set(entry.sliceId, bySpan);
+    }
+    const closedSlices = new Set();
+    for (const [sliceId, bySpan] of bySlice.entries()) {
+        for (const rows of bySpan.values()) {
+            const phases = new Set(rows
+                .filter((row) => row.status === "completed" && typeof row.phase === "string")
+                .map((row) => row.phase));
+            const hasRed = phases.has("red");
+            const hasGreen = phases.has("green");
+            const hasDoc = phases.has("doc");
+            if (hasRed && hasGreen && hasDoc && hasRefactorCoverage(rows)) {
+                closedSlices.add(sliceId);
+                break;
+            }
+        }
+    }
+    return [...closedSlices].sort();
+}
+async function hasManagedCommitForSlice(projectRoot, sliceId) {
+    const grep = `^${escapeRegex(sliceId)}/`;
+    const { stdout } = await execFileAsync("git", ["log", "--format=%s%n%b", "--grep", grep], { cwd: projectRoot });
+    return stdout.trim().length > 0;
+}
 export async function validateTddVerificationEvidence(projectRoot, evidence, options = {}) {
     const normalized = evidence.trim();
-    const mode = "auto";
+    const config = await readConfig(projectRoot).catch(() => null);
+    const commitMode = resolveTddCommitMode(config);
+    const mode = commitMode === "off" ? "disabled" : "auto";
     const gitPresent = await exists(path.join(projectRoot, ".git"));
     const issues = [];
     if (options.requireCommand !== false && !TEST_COMMAND_HINT_PATTERN.test(normalized)) {
@@ -16,16 +89,34 @@ export async function validateTddVerificationEvidence(projectRoot, evidence, opt
     if (options.requirePassStatus !== false && !PASS_STATUS_PATTERN.test(normalized)) {
         issues.push("GREEN repair needed: include explicit success status (for example `PASS` or `GREEN`).");
     }
-    const hasSha = SHA_WITH_LABEL_PATTERN.test(normalized);
-    const hasNoVcs = NO_VCS_ATTESTATION_PATTERN.test(normalized);
-    if (mode === "auto" && gitPresent && !hasSha) {
-        issues.push("must include a commit SHA token prefixed with `sha` or `commit` (for example `sha: abc1234`).");
-    }
-    else if (mode === "auto" && !gitPresent && !hasSha && !hasNoVcs) {
-        issues.push("must include either a commit SHA or an explicit no-VCS attestation (for example `no-vcs: project has no .git directory`).");
+    if (mode !== "disabled" && commitMode === "managed-per-slice" && gitPresent) {
+        const ledger = await readDelegationLedger(projectRoot).catch(() => null);
+        if (ledger && typeof ledger.runId === "string" && ledger.runId.length > 0) {
+            const closedSlices = collectClosedSlices(ledger.entries, ledger.runId);
+            const missing = [];
+            for (const sliceId of closedSlices) {
+                const hasCommit = await hasManagedCommitForSlice(projectRoot, sliceId).catch(() => false);
+                if (!hasCommit) {
+                    missing.push(sliceId);
+                }
+            }
+            if (missing.length > 0) {
+                issues.push(`managed-per-slice commit check failed: missing git commit(s) for closed slice(s): ${missing.join(", ")}.`);
+            }
+        }
     }
-    else if (mode === "auto" && !gitPresent && hasNoVcs && !NO_VCS_HASH_PATTERN.test(normalized)) {
-        issues.push("NO_VCS_MODE repair needed: include a content/artifact hash for no-VCS TDD evidence (for example `artifact-hash: sha256:<hash>`).");
+    else if (mode === "auto") {
+        const hasSha = SHA_WITH_LABEL_PATTERN.test(normalized);
+        const hasNoVcs = NO_VCS_ATTESTATION_PATTERN.test(normalized);
+        if (gitPresent && !hasSha) {
+            issues.push("must include a commit SHA token prefixed with `sha` or `commit` (for example `sha: abc1234`).");
+        }
+        else if (!gitPresent && !hasSha && !hasNoVcs) {
+            issues.push("must include either a commit SHA or an explicit no-VCS attestation (for example `no-vcs: project has no .git directory`).");
+        }
+        else if (!gitPresent && hasNoVcs && !NO_VCS_HASH_PATTERN.test(normalized)) {
+            issues.push("NO_VCS_MODE repair needed: include a content/artifact hash for no-VCS TDD evidence (for example `artifact-hash: sha256:<hash>`).");
+        }
     }
     return { ok: issues.length === 0, issues, mode, gitPresent };
 }

package/dist/types.d.ts

@@ -161,10 +161,22 @@ export interface ReviewLoopConfig {
     externalSecondOpinion?: ReviewLoopExternalSecondOpinionConfig;
 }
 export type VcsMode = "git-with-remote" | "git-local-only" | "none";
+export type TddCommitMode = "managed-per-slice" | "agent-required" | "checkpoint-only" | "off";
+export interface TddConfig {
+    /**
+     * Commit ownership model for closed TDD slices.
+     * - managed-per-slice: cclaw-generated hook performs one commit per closed slice.
+     * - agent-required: worker/controller must create the commit outside cclaw.
+     * - checkpoint-only: coarse-grained checkpoints are allowed (no per-slice enforcement).
+     * - off: skip commit-shape enforcement.
+     */
+    commitMode?: TddCommitMode;
+}
 export interface CclawConfig {
     version: string;
     flowVersion: string;
     harnesses: HarnessId[];
+    tdd?: TddConfig;
 }
 export interface TransitionRule {
     from: FlowStage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "7.0.5",
+  "version": "7.1.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {