cclaw-cli 0.51.27 → 0.51.28

package/dist/artifact-linter.js

@@ -105,6 +105,24 @@ function sectionBodyByHeadingPrefix(sections, prefix) {
     }
     return null;
 }
+/**
+ * Build a regex that matches `<field>: <value>` even when the field name
+ * and/or value are wrapped in markdown emphasis (`*`, `**`, `_`, `__`).
+ *
+ * The shipped templates render fields as `- **Field name:** value`, so any
+ * structural check that searches for `Field:\s*token` against the rendered
+ * artifact must tolerate the closing `**` between the colon and the value.
+ *
+ * `field` is treated as literal text (regex meta-characters are escaped).
+ * `value` is inserted verbatim so callers can pass alternation
+ * (`STARTUP|BUILDER|...`). `flags` defaults to case-insensitive Unicode.
+ */
+function markdownFieldRegex(field, value, flags = "iu") {
+    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const emph = "[*_]{0,2}";
+    const source = `(?:^|[\\s>])${emph}\\s*${escapedField}\\s*${emph}\\s*:\\s*${emph}\\s*(?:${value})\\b`;
+    return new RegExp(source, flags);
+}
 export function extractMarkdownSectionBody(markdown, section) {
     return sectionBodyByName(extractH2Sections(markdown), section);
 }
@@ -211,7 +229,7 @@ function normalizeDesignDiagramTier(value) {
     if (!value)
         return null;
     const normalized = value.trim().toLowerCase();
-    if (/^light(?:weight)?$/u.test(normalized))
+    if (/^(?:lite|light|lightweight)$/u.test(normalized))
         return "lightweight";
     if (/^standard$/u.test(normalized))
         return "standard";
@@ -224,12 +242,21 @@ function parseApproachTierSection(sectionBody) {
         return null;
     for (const line of sectionBody.split(/\r?\n/u)) {
         const cleaned = line.replace(/[*_`]/gu, "").trim();
-        const directMatch = /(?:^|\b)tier\s*:\s*(lightweight|light|standard|deep)\b/iu.exec(cleaned);
+        const directMatch = /(?:^|\b)tier\s*:\s*(lite|lightweight|light|standard|deep)\b/iu.exec(cleaned);
         if (directMatch) {
-            return normalizeDesignDiagramTier(directMatch[1] ?? null);
+            const captured = directMatch[1] ?? "";
+            const remainder = cleaned.slice(cleaned.toLowerCase().indexOf("tier") + 4);
+            const tierTokens = remainder.match(/\b(?:lite|lightweight|light|standard|deep)\b/giu) ?? [];
+            const distinct = new Set(tierTokens.map((token) => token.toLowerCase()));
+            if (distinct.size >= 2) {
+                // Multi-token line is the unfilled template placeholder
+                // (`Tier: lite | standard | deep`); treat as no decision.
+                continue;
+            }
+            return normalizeDesignDiagramTier(captured);
         }
     }
-    const token = /\b(lightweight|light|standard|deep)\b/iu.exec(sectionBody)?.[1] ?? null;
+    const token = /\b(lite|lightweight|light|standard|deep)\b/iu.exec(sectionBody)?.[1] ?? null;
     return normalizeDesignDiagramTier(token);
 }
 async function resolveDesignDiagramTier(projectRoot, track, designRaw) {
@@ -1782,15 +1809,31 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         // to a single row (defeating the "2-3 distinct approaches" gate).
         const tierBody = sectionBodyByName(sections, "Approach Tier");
         if (tierBody !== null) {
-            const hasTierToken = /\b(?:lightweight|standard|deep)\b/iu.test(tierBody);
+            // Token vocabulary covers `lite`, `Lightweight`, `Standard`, and
+            // `Deep` (case-insensitive). A line that lists ≥2 distinct tokens is
+            // the unfilled template placeholder (`Tier: lite | standard | deep`)
+            // and must not silently pass; we look for at least one decision line
+            // with exactly one token, while ignoring placeholder lines.
+            const cleanedLines = tierBody
+                .split("\n")
+                .map((line) => line.replace(/[*_`]/gu, ""));
+            const lineTokenCounts = cleanedLines.map((line) => {
+                const tokens = line.match(/\b(?:lite|lightweight|light|standard|deep)\b/giu) ?? [];
+                return new Set(tokens.map((token) => token.toLowerCase())).size;
+            });
+            const hasDecisionLine = lineTokenCounts.some((count) => count === 1);
+            const hasPlaceholderLine = lineTokenCounts.some((count) => count >= 2);
+            const ok = hasDecisionLine;
             findings.push({
                 section: "Approach Tier Classification",
                 required: true,
-                rule: "Approach Tier must explicitly classify depth as Lightweight, Standard, or Deep.",
-                found: hasTierToken,
-                details: hasTierToken
-                    ? "Approach Tier includes a recognized depth token."
-                    : "Approach Tier is missing a recognized depth token (Lightweight/Standard/Deep)."
+                rule: "Approach Tier must explicitly classify depth as one of `lite` (a.k.a. `Lightweight`), `Standard`, or `Deep`.",
+                found: ok,
+                details: ok
+                    ? "Approach Tier includes a single recognized depth token."
+                    : hasPlaceholderLine
+                        ? "Approach Tier still lists multiple tier tokens (template placeholder); pick exactly one of `lite`/`Lightweight`, `Standard`, or `Deep`."
+                        : "Approach Tier is missing a recognized depth token (`lite`/`Lightweight`, `Standard`, or `Deep`)."
             });
         }
         const approachesBody = sectionBodyByName(sections, "Approaches");
@@ -1931,16 +1974,30 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         // approach detail cards, anti-sycophancy stamp).
         const modeBody = sectionBodyByName(sections, "Mode Block");
         if (modeBody !== null) {
-            const modeRegex = /\bMode:\s*(STARTUP|BUILDER|ENGINEERING|OPS|RESEARCH)\b/u;
-            const ok = modeRegex.test(modeBody);
+            const modeTokens = ["STARTUP", "BUILDER", "ENGINEERING", "OPS", "RESEARCH"];
+            const modeRegex = markdownFieldRegex("Mode", modeTokens.join("|"), "u");
+            const tokenMatches = new Set();
+            const lineRegex = new RegExp(modeRegex.source, "gu");
+            for (const match of modeBody.matchAll(lineRegex)) {
+                const token = (match[0].match(/STARTUP|BUILDER|ENGINEERING|OPS|RESEARCH/u) ?? [""])[0];
+                if (token)
+                    tokenMatches.add(token);
+            }
+            const placeholderLine = modeBody
+                .split("\n")
+                .find((line) => /\bMode\b\s*[*_]{0,2}\s*:/iu.test(line) && (line.match(/STARTUP|BUILDER|ENGINEERING|OPS|RESEARCH/giu) ?? []).length >= 2);
+            const isPlaceholder = Boolean(placeholderLine);
+            const ok = tokenMatches.size === 1 && !isPlaceholder;
             findings.push({
                 section: "Mode Block Token",
                 required: true,
                 rule: "Mode Block must declare exactly one mode token: STARTUP, BUILDER, ENGINEERING, OPS, or RESEARCH.",
                 found: ok,
                 details: ok
-                    ? "Recognized mode token detected."
-                    : "Mode Block is missing a recognized mode token (STARTUP/BUILDER/ENGINEERING/OPS/RESEARCH)."
+                    ? `Recognized mode token detected: ${[...tokenMatches][0] ?? ""}.`
+                    : isPlaceholder
+                        ? "Mode Block still lists multiple mode tokens (template placeholder); pick exactly one of STARTUP/BUILDER/ENGINEERING/OPS/RESEARCH."
+                        : "Mode Block is missing a recognized mode token (STARTUP/BUILDER/ENGINEERING/OPS/RESEARCH)."
             });
         }
         const forcingBody = sectionBodyByName(sections, "Forcing Questions");
@@ -2038,7 +2095,7 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         }
         const stampBody = sectionBodyByName(sections, "Anti-Sycophancy Stamp");
         if (stampBody !== null) {
-            const acknowledged = /forbidden response openers acknowledged:\s*(yes|true|y)\b/iu.test(stampBody);
+            const acknowledged = markdownFieldRegex("Forbidden response openers acknowledged", "yes|true|y").test(stampBody);
             findings.push({
                 section: "Anti-Sycophancy Acknowledgement",
                 required: true,
@@ -2137,7 +2194,7 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         }
         const regressionBody = sectionBodyByName(sections, "Regression Iron Rule");
         if (regressionBody !== null) {
-            const ack = /iron rule acknowledged:\s*(yes|true|y)\b/iu.test(regressionBody);
+            const ack = markdownFieldRegex("Iron rule acknowledged", "yes|true|y").test(regressionBody);
             findings.push({
                 section: "Regression Iron Rule Acknowledgement",
                 required: true,

package/dist/content/state-contracts.js

@@ -12,7 +12,7 @@ const REQUIRED_TOP_LEVEL_FIELDS = {
 };
 const STAGE_TAXONOMIES = {
     brainstorm: {
-        approachTier: ["Lightweight", "Standard", "Deep"],
+        approachTier: ["Lightweight", "Standard", "Deep", "lite", "standard", "deep"],
         approachRole: ["baseline", "challenger", "wild-card"],
         approachUpside: ["low", "modest", "high", "higher"]
     },

package/package.json

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