cclaw-cli 0.51.10 → 0.51.12

package/dist/artifact-linter.js

@@ -303,26 +303,6 @@ function tokensFromRule(rule) {
     }
     return [];
 }
-/**
- * Extract required keywords from validation rules that contain *backticked*
- * stable tokens after a colon. We only fire on machine-surface enumerations
- * (e.g., `` Must contain: `Status:`, `WAIT_FOR_CONFIRM`, `Approved:` ``);
- * descriptive English prose with bare comma lists is intentionally ignored so
- * authors can write rationale freely without triggering hardcoded keyword
- * matches. Sections that need richer structural enforcement use a dedicated
- * `validateSectionBody` dispatch (see `validateScopeSummary`, etc.).
- */
-function extractRequiredKeywords(rule) {
-    const colonMatch = /:\s*(.+)$/u.exec(rule);
-    if (!colonMatch)
-        return [];
-    const tail = colonMatch[1];
-    const backtickedTokens = Array.from(tail.matchAll(/`([^`]+)`/gu)).map((m) => m[1].trim());
-    const phrases = backtickedTokens.filter((p) => p.length >= 2);
-    if (phrases.length < 3)
-        return [];
-    return phrases;
-}
 const VAGUE_AC_ADJECTIVES = [
     "fast",
     "quick",
@@ -368,35 +348,6 @@ function getMarkdownTableRows(sectionBody) {
     }
     return rows;
 }
-function getApproachRows(sectionBody) {
-    const tableRows = getMarkdownTableRows(sectionBody).map((row) => row.join(" "));
-    const headingRows = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^#{3,6}\s+\S/u.test(line))
-        .map((line) => line.replace(/^#{3,6}\s+/u, ""));
-    const bulletRows = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^(?:[-*]|\d+\.)\s+\S/u.test(line));
-    return [...tableRows, ...headingRows, ...bulletRows];
-}
-function hasSemanticChallenger(row) {
-    const normalized = row
-        .replace(/[_`*]/gu, " ")
-        .replace(/\s+/gu, " ")
-        .trim()
-        .toLowerCase();
-    const isChallenger = /\bchallenger\b/u.test(normalized);
-    if (!isChallenger)
-        return false;
-    return (/\bhigher[-\s]?upside\b/u.test(normalized) ||
-        /\bhigh[-\s]?upside\b/u.test(normalized) ||
-        /\bupside\s*:?\s*(?:high|higher|strong|large|meaningful)\b/u.test(normalized) ||
-        /\b(?:high|higher|strong|large|meaningful)\s+upside\b/u.test(normalized) ||
-        /\b(?:10-star|ten-star|ambitious|higher leverage|leverage)\b/u.test(normalized) ||
-        /\bhigh\b/u.test(normalized));
-}
 function parseBinaryFlag(value) {
     const normalized = value.trim().toLowerCase();
     if (/^(?:y|yes|true|1)$/u.test(normalized))
@@ -550,13 +501,14 @@ function validatePremiseChallenge(sectionBody) {
     if (rowCount < 3) {
         return {
             ok: false,
-            details: `Premise Challenge needs at least 3 question/answer rows in a table or bullet list (right problem? / direct path? / what if nothing? are the gstack default trio). Found ${rowCount}.`
+            details: `Premise Challenge needs at least 3 substantive rows in a table or bullet list. Found ${rowCount}.`
         };
     }
     // For tables, each data row must have at least 2 non-empty cells so the
-    // section is genuinely a Q/A comparison, not a list of headlines. For
-    // bullet lists, each line must be substantive (>= 8 characters of letters
-    // or digits) so we don't accept three-letter placeholders like `- a`.
+    // section is genuinely a premise/answer comparison, not a list of headlines.
+    // For bullet lists, each line must be substantive so we don't accept
+    // placeholders like `- a`; punctuation style and natural language do not
+    // matter.
     if (tableRows.length >= 3) {
         const sparseRows = tableRows.filter((row) => {
             const filledCells = row.filter((cell) => cell.replace(/[\s|]/gu, "").length >= 2);
@@ -572,14 +524,13 @@ function validatePremiseChallenge(sectionBody) {
     else if (bulletRows.length >= 3) {
         const sparseBullets = bulletRows.filter((line) => {
             const cleaned = line.replace(/^[-*\d.\s]+/u, "").replace(/[`*_]/gu, "").trim();
-            const hasQuestionMark = /\?/u.test(cleaned);
             const meaningful = cleaned.match(/[\p{L}\p{N}]/gu)?.length ?? 0;
-            return !hasQuestionMark && meaningful < 12;
+            return meaningful < 12;
         });
-        if (sparseBullets.length > bulletRows.length - 3) {
+        if (sparseBullets.length > 0) {
             return {
                 ok: false,
-                details: "Premise Challenge bullet list must include at least 3 substantive Q/A lines (a question mark plus the answer, or a labelled `Question: answer` pair)."
+                details: "Premise Challenge bullet list must include at least 3 substantive rows, not placeholders."
             };
         }
     }
@@ -616,6 +567,114 @@ function validateScopeSummary(sectionBody) {
         details: "Scope Summary names the selected mode and the next-stage handoff."
     };
 }
+const APPROACH_ROLE_VALUES = ["baseline", "challenger", "wild-card"];
+const APPROACH_UPSIDE_VALUES = ["low", "modest", "high", "higher"];
+const REQUIREMENT_PRIORITY_VALUES = ["P0", "P1", "P2", "P3", "DROPPED"];
+function normalizeTableToken(value) {
+    return value
+        .replace(/[`*_]/gu, "")
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/gu, "-");
+}
+function columnIndex(header, expected) {
+    return header.findIndex((cell) => normalizeTableToken(cell) === expected);
+}
+function validateApproachesTaxonomy(sectionBody) {
+    const header = tableHeaderCells(sectionBody);
+    const rows = getMarkdownTableRows(sectionBody);
+    if (!header) {
+        return {
+            rowCount: 0,
+            roleUpsideOk: false,
+            challengerOk: false,
+            details: "Approaches must be a markdown table with canonical Role and Upside columns."
+        };
+    }
+    const roleIndex = columnIndex(header, "role");
+    const upsideIndex = columnIndex(header, "upside");
+    if (roleIndex < 0 || upsideIndex < 0) {
+        return {
+            rowCount: rows.length,
+            roleUpsideOk: false,
+            challengerOk: false,
+            details: "Approaches table must include canonical `Role` and `Upside` columns (Role: baseline | challenger | wild-card; Upside: low | modest | high | higher)."
+        };
+    }
+    let challengerRows = 0;
+    let challengerHasHighUpside = false;
+    for (const [index, row] of rows.entries()) {
+        const role = normalizeTableToken(row[roleIndex] ?? "");
+        const upside = normalizeTableToken(row[upsideIndex] ?? "");
+        if (!APPROACH_ROLE_VALUES.includes(role)) {
+            return {
+                rowCount: rows.length,
+                roleUpsideOk: false,
+                challengerOk: false,
+                details: `Approaches row ${index + 1} has invalid Role "${row[roleIndex] ?? ""}". Expected one of: ${APPROACH_ROLE_VALUES.join(", ")}.`
+            };
+        }
+        if (!APPROACH_UPSIDE_VALUES.includes(upside)) {
+            return {
+                rowCount: rows.length,
+                roleUpsideOk: false,
+                challengerOk: false,
+                details: `Approaches row ${index + 1} has invalid Upside "${row[upsideIndex] ?? ""}". Expected one of: ${APPROACH_UPSIDE_VALUES.join(", ")}.`
+            };
+        }
+        if (role === "challenger") {
+            challengerRows += 1;
+            if (upside === "high" || upside === "higher") {
+                challengerHasHighUpside = true;
+            }
+        }
+    }
+    const challengerOk = challengerRows === 1 && challengerHasHighUpside;
+    return {
+        rowCount: rows.length,
+        roleUpsideOk: true,
+        challengerOk,
+        details: challengerOk
+            ? "Approaches table uses canonical Role/Upside values and exactly one high/higher-upside challenger."
+            : `Approaches table must include exactly one challenger row with Upside high or higher. Found ${challengerRows} challenger row(s).`
+    };
+}
+function validateRequirementsTaxonomy(sectionBody) {
+    const header = tableHeaderCells(sectionBody);
+    if (!header) {
+        return {
+            ok: false,
+            details: "Requirements must be a markdown table with a Priority column."
+        };
+    }
+    const priorityIndex = columnIndex(header, "priority");
+    if (priorityIndex < 0) {
+        return {
+            ok: false,
+            details: "Requirements table must include a canonical `Priority` column."
+        };
+    }
+    const rows = getMarkdownTableRows(sectionBody);
+    if (rows.length === 0) {
+        return {
+            ok: false,
+            details: "Requirements table must include at least one requirement row."
+        };
+    }
+    for (const [index, row] of rows.entries()) {
+        const rawPriority = (row[priorityIndex] ?? "").replace(/[`*_]/gu, "").trim().toUpperCase();
+        if (!REQUIREMENT_PRIORITY_VALUES.includes(rawPriority)) {
+            return {
+                ok: false,
+                details: `Requirements row ${index + 1} has invalid Priority "${row[priorityIndex] ?? ""}". Expected one of: ${REQUIREMENT_PRIORITY_VALUES.join(", ")}.`
+            };
+        }
+    }
+    return {
+        ok: true,
+        details: "Requirements table uses canonical Priority values."
+    };
+}
 const INTERACTION_EDGE_CASE_REQUIREMENTS = [
     { label: "double-click", pattern: /\bdouble[\s-]?click\b/iu },
     {
@@ -1342,6 +1401,9 @@ function validateSectionBody(sectionBody, rule, sectionName) {
     if (sectionNameNormalized === "premise challenge") {
         return validatePremiseChallenge(sectionBody);
     }
+    if (sectionNameNormalized === "requirements") {
+        return validateRequirementsTaxonomy(sectionBody);
+    }
     if (sectionNameNormalized === "data flow") {
         return validateInteractionEdgeCaseMatrix(sectionBody);
     }
@@ -1379,21 +1441,6 @@ function validateSectionBody(sectionBody, rule, sectionName) {
             };
         }
     }
-    if (sectionNameNormalized !== "architecture diagram") {
-        const keywords = extractRequiredKeywords(rule);
-        if (keywords.length > 0) {
-            const bodyLower = sectionBody.toLowerCase();
-            const found = keywords.filter((kw) => bodyLower.includes(kw.toLowerCase()));
-            const threshold = Math.ceil(keywords.length * 0.5);
-            if (found.length < threshold) {
-                const missing = keywords.filter((kw) => !bodyLower.includes(kw.toLowerCase()));
-                return {
-                    ok: false,
-                    details: `Rule expects keywords (${threshold}/${keywords.length} minimum): missing ${missing.join(", ")}.`
-                };
-            }
-        }
-    }
     if (sectionNameNormalized === "acceptance criteria" &&
         /observable[\s,]*measurable[\s,]+(and )?falsifiable/iu.test(rule)) {
         const rows = getMarkdownTableRows(sectionBody);
@@ -1568,31 +1615,29 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         }
         const approachesBody = sectionBodyByName(sections, "Approaches");
         if (approachesBody !== null) {
-            const tableRows = getMarkdownTableRows(approachesBody);
-            const bulletRows = approachesBody
-                .split(/\r?\n/u)
-                .map((line) => line.trim())
-                .filter((line) => /^(?:[-*]|\d+\.)\s+\S/u.test(line));
-            const rowCount = Math.max(tableRows.length, bulletRows.length);
-            const approachRows = getApproachRows(approachesBody);
-            const hasChallenger = approachRows.some(hasSemanticChallenger);
+            const approachesTaxonomy = validateApproachesTaxonomy(approachesBody);
             findings.push({
                 section: "Distinct Approaches Enforcement",
                 required: true,
                 rule: "Approaches section must document at least 2 distinct approaches so the Iron Law comparison is meaningful.",
-                found: rowCount >= 2,
-                details: rowCount >= 2
-                    ? `Detected ${rowCount} approach row(s).`
-                    : `Detected ${rowCount} approach row(s); at least 2 required.`
+                found: approachesTaxonomy.rowCount >= 2,
+                details: approachesTaxonomy.rowCount >= 2
+                    ? `Detected ${approachesTaxonomy.rowCount} approach row(s).`
+                    : `Detected ${approachesTaxonomy.rowCount} approach row(s); at least 2 required.`
+            });
+            findings.push({
+                section: "Approaches Role/Upside Taxonomy",
+                required: true,
+                rule: "Approaches table must use canonical Role and Upside enum values.",
+                found: approachesTaxonomy.roleUpsideOk,
+                details: approachesTaxonomy.details
             });
             findings.push({
                 section: "Challenger Alternative Enforcement",
                 required: true,
                 rule: "Approaches must include one challenger option with explicit high/higher upside.",
-                found: hasChallenger,
-                details: hasChallenger
-                    ? "Semantic challenger with high/higher upside detected."
-                    : "Missing a challenger option with explicit high/higher upside. Example: `| C | challenger | high upside | More ambitious path with clear trade-offs |`."
+                found: approachesTaxonomy.challengerOk,
+                details: approachesTaxonomy.details
             });
         }
         const reactionIndex = headingLineIndex(raw, "Approach Reaction");

package/dist/content/examples.js

@@ -31,11 +31,11 @@ const STAGE_EXAMPLES = {
 
 ## Approaches
 
-| Approach | Role | Architecture | Trade-offs | Recommendation |
-| --- | --- | --- | --- | --- |
-| A: Reusable validation module | baseline | Shared TS module with typed validators, imported by CI scripts and local CLI. Existing \`pre-publish.sh\` calls the module. | Medium upfront effort, high reuse. Requires test coverage for the module. | **Recommended** — best balance of reuse and delivery speed. |
-| B: Hardened shell scripts | fallback | Keep existing script approach, add stricter checks and error messages. | Lowest effort. Weak reuse, CI/local divergence risk grows over time. | Viable fallback if TS module is blocked. |
-| C: Full release framework | challenger: higher-upside | New release orchestrator with plugin system, config files, rollback commands. | Maximum flexibility. High risk, delivery delay, over-engineered for current needs. | Not recommended for v1. |
+| Approach | Role | Upside | Architecture | Trade-offs | Recommendation |
+| --- | --- | --- | --- | --- | --- |
+| A: Reusable validation module | baseline | high | Shared TS module with typed validators, imported by CI scripts and local CLI. Existing \`pre-publish.sh\` calls the module. | Medium upfront effort, high reuse. Requires test coverage for the module. | **Recommended** — best balance of reuse and delivery speed. |
+| B: Hardened shell scripts | baseline | modest | Keep existing script approach, add stricter checks and error messages. | Lowest effort. Weak reuse, CI/local divergence risk grows over time. | Viable fallback if TS module is blocked. |
+| C: Full release framework | challenger | higher | New release orchestrator with plugin system, config files, rollback commands. | Maximum flexibility. High risk, delivery delay, over-engineered for current needs. | Not recommended for v1. |
 
 ## Approach Reaction
 

package/package.json

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