cclaw-cli 0.51.27 → 0.51.29

package/dist/tdd-cycle.js

@@ -95,7 +95,7 @@ export function validateTddCycleOrder(entries, options = {}) {
     // cycles could appear to share a RED/GREEN pair.
     for (const slice of bySlice.keys()) {
         if (!SLICE_ID_PATTERN.test(slice)) {
-            issues.push(`slice "${slice}": id must match /^S-\\d+$/ (e.g. S-1)`);
+            issues.push(`slice "${slice}": id must match /^S-\\d+$/ (e.g. S-1); repair by re-logging RED/GREEN/REFACTOR with a stable slice id.`);
         }
     }
     for (const [slice, sliceEntries] of bySlice.entries()) {
@@ -103,15 +103,15 @@ export function validateTddCycleOrder(entries, options = {}) {
         for (const entry of sliceEntries) {
             if (entry.phase === "red") {
                 if (entry.exitCode === undefined) {
-                    issues.push(`slice ${slice}: red entry must record a non-zero exitCode`);
+                    issues.push(`slice ${slice}: RED repair needed: red entry must record a non-zero exitCode from a failing test.`);
                     continue;
                 }
                 if (entry.exitCode === 0) {
-                    issues.push(`slice ${slice}: red entry exitCode must be non-zero`);
+                    issues.push(`slice ${slice}: RED repair needed: red entry exitCode must be non-zero; passing output is not RED evidence.`);
                     continue;
                 }
                 if (state === "red_open") {
-                    issues.push(`slice ${slice}: duplicate red before green`);
+                    issues.push(`slice ${slice}: RED/GREEN repair needed: duplicate RED before GREEN; record the GREEN pass that closes the prior RED or split into a new slice.`);
                     continue;
                 }
                 state = "red_open";
@@ -119,15 +119,15 @@ export function validateTddCycleOrder(entries, options = {}) {
             }
             if (entry.phase === "green") {
                 if (entry.exitCode === undefined) {
-                    issues.push(`slice ${slice}: green entry must record exitCode 0`);
+                    issues.push(`slice ${slice}: GREEN repair needed: green entry must record exitCode 0 from the verification command.`);
                     continue;
                 }
                 if (entry.exitCode !== 0) {
-                    issues.push(`slice ${slice}: green entry exitCode must be 0`);
+                    issues.push(`slice ${slice}: GREEN repair needed: green entry exitCode must be 0; fix regressions before advancing.`);
                     continue;
                 }
                 if (state !== "red_open") {
-                    issues.push(`slice ${slice}: green logged before red`);
+                    issues.push(`slice ${slice}: GREEN repair needed: green logged before RED; add the failing RED test evidence first.`);
                     continue;
                 }
                 state = "green_done";
@@ -135,15 +135,15 @@ export function validateTddCycleOrder(entries, options = {}) {
             }
             // refactor — must preserve the passing state established by green.
             if (entry.exitCode === undefined) {
-                issues.push(`slice ${slice}: refactor entry must record exitCode 0`);
+                issues.push(`slice ${slice}: REFACTOR repair needed: refactor entry must record exitCode 0 proving behavior stayed green.`);
                 continue;
             }
             if (entry.exitCode !== 0) {
-                issues.push(`slice ${slice}: refactor entry exitCode must be 0 (tests must stay green)`);
+                issues.push(`slice ${slice}: REFACTOR repair needed: tests must stay green after cleanup; rerun/fix before closing the slice.`);
                 continue;
             }
             if (state !== "green_done") {
-                issues.push(`slice ${slice}: refactor logged before green`);
+                issues.push(`slice ${slice}: REFACTOR repair needed: refactor logged before GREEN; prove GREEN first, then cleanup.`);
                 continue;
             }
         }

package/dist/tdd-verification-evidence.js

@@ -14,20 +14,20 @@ export async function validateTddVerificationEvidence(projectRoot, evidence, opt
     const gitPresent = configuredVcs !== "none" && await exists(path.join(projectRoot, ".git"));
     const issues = [];
     if (options.requireCommand !== false && !TEST_COMMAND_HINT_PATTERN.test(normalized)) {
-        issues.push("must include the fresh verification command that was run (for example `npm test`, `pytest`, `go test`, or equivalent).");
+        issues.push("GREEN repair needed: include the fresh verification command that was run (for example `npm test`, `pytest`, `go test`, or equivalent).");
     }
     if (options.requirePassStatus !== false && !PASS_STATUS_PATTERN.test(normalized)) {
-        issues.push("must include explicit success status (for example `PASS` or `GREEN`).");
+        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);
     const hasNoVcsHash = NO_VCS_HASH_PATTERN.test(normalized);
     if (mode !== "disabled" && configuredVcs === "none") {
         if (!hasNoVcs) {
-            issues.push("must include an explicit no-VCS reason because `vcs` is `none`.");
+            issues.push("NO_VCS_MODE repair needed: include an explicit no-VCS reason because `vcs` is `none`.");
         }
         if (!hasNoVcsHash) {
-            issues.push("must include a content/artifact hash for no-VCS TDD evidence (for example `artifact-hash: sha256:<hash>`).");
+            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 === "required" && !hasSha) {

package/dist/track-heuristics.d.ts

@@ -3,6 +3,8 @@ export interface TrackResolution {
     track: FlowTrack;
     reason: string;
     matchedTokens: string[];
+    confidence: "high" | "medium" | "low";
+    overrideGuidance: string;
 }
 /**
  * Reference implementation of the track classifier the /cc skill prose

package/dist/track-heuristics.js

@@ -111,15 +111,23 @@ export function resolveTrackFromPrompt(prompt, config) {
         if (matched.length > 0) {
             return {
                 track,
-                reason: `matched ${track} heuristic`,
-                matchedTokens: matched
+                reason: `matched ${track} heuristic (${matched.join(", ")})`,
+                matchedTokens: matched,
+                confidence: matched.length > 1 ? "high" : "medium",
+                overrideGuidance: track === "quick"
+                    ? "Use medium/standard instead when product framing, architecture, schema, migration, security, or unclear scope appears; quick skips ceremony, not safety."
+                    : track === "medium"
+                        ? "Use standard if architecture, data model, security boundary, or migration risk is uncertain."
+                        : "Use medium or quick only when the blast radius and architecture are already known."
             };
         }
     }
     return {
         track: fallback,
         reason: `no explicit match, fallback=${fallback}`,
-        matchedTokens: []
+        matchedTokens: [],
+        confidence: "low",
+        overrideGuidance: "Confirm or override before state is written; choose quick only for known low-blast-radius work, medium for known architecture with product framing, standard for uncertainty."
     };
 }
 export const TRACK_HEURISTICS_DEFAULTS = {

package/package.json

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