cclaw-cli 0.22.0 → 0.23.1

package/dist/eval/runner.d.ts

@@ -4,11 +4,11 @@ export interface RunEvalOptions {
     projectRoot: string;
     stage?: FlowStage;
     tier?: EvalTier;
-    /** When true, run only structural verifiers. Wave 7.1 wires actual verifiers. */
+    /** When true, run only structural verifiers (Step 1). */
     schemaOnly?: boolean;
-    /** When true, run structural + rule-based verifiers. Wave 7.2 wires rules. */
+    /** When true, run structural + rule-based verifiers. Step 2 wires rules. */
     rules?: boolean;
-    /** When true, also run LLM judge verifiers. Wave 7.3 wires judging. */
+    /** When true, also run LLM judge verifiers. Step 3 wires judging. */
     judge?: boolean;
     /** When true, load config + corpus and return a summary without running any verifier. */
     dryRun?: boolean;
@@ -27,10 +27,6 @@ export interface DryRunSummary {
         }>;
     };
     plannedTier: EvalTier;
-    /**
-     * Waves 7.1–7.3 progressively flip these to `true`. Wave 7.0 is `false`
-     * across the board because no verifier is implemented yet.
-     */
     verifiersAvailable: {
         structural: boolean;
         rules: boolean;
@@ -40,14 +36,10 @@ export interface DryRunSummary {
     notes: string[];
 }
 /**
- * Wave 7.0 runner. Responsibilities:
- * - Load resolved config (defaults + file + env).
- * - Load corpus (empty on a fresh install).
- * - Validate that no verifier flag asks for a capability that does not exist yet.
- * - Return either a dry-run summary or an empty report.
- *
- * Waves 7.1+ will replace the "no verifiers available" branch with the real
- * verifier dispatch pipeline. The signature stays stable so CLI wiring does
- * not churn.
+ * Structural runner. When `schemaOnly` is set (or no other verifier flags are
+ * active), runs structural verifiers against fixture-backed cases and loads
+ * per-stage baselines for regression comparison. Tier A/B/C agent loops
+ * arrive in later steps; until then cases without `fixture` are marked as
+ * skipped rather than failing.
  */
 export declare function runEval(options: RunEvalOptions): Promise<DryRunSummary | EvalReport>;

package/dist/eval/runner.js

@@ -1,23 +1,121 @@
 import { randomUUID } from "node:crypto";
 import { CCLAW_VERSION } from "../constants.js";
-import { loadCorpus } from "./corpus.js";
+import { FLOW_STAGES } from "../types.js";
+import { compareAgainstBaselines, loadBaselinesByStage } from "./baseline.js";
+import { loadCorpus, readFixtureArtifact } from "./corpus.js";
 import { loadEvalConfig } from "./config-loader.js";
+import { verifyStructural } from "./verifiers/structural.js";
 function groupByStage(cases) {
     return cases.reduce((acc, item) => {
         acc[item.stage] = (acc[item.stage] ?? 0) + 1;
         return acc;
     }, {});
 }
+function skeletonVerifierResult(message, details) {
+    return {
+        kind: "structural",
+        id: "structural:no-expectations",
+        ok: true,
+        score: 1,
+        message,
+        ...(details !== undefined ? { details } : {})
+    };
+}
+async function runCaseStructural(projectRoot, caseEntry, plannedTier) {
+    const started = Date.now();
+    const structuralExpected = caseEntry.expected?.structural;
+    const verifierResults = [];
+    if (!structuralExpected || Object.keys(structuralExpected).length === 0) {
+        // No structural expectations declared — case is treated as "N/A" for this
+        // verifier kind; a placeholder pass keeps downstream math simple while
+        // making the situation visible in the report.
+        verifierResults.push(skeletonVerifierResult("No structural expectations declared for this case; structural verifier skipped.", { skipped: true }));
+    }
+    else {
+        let artifact;
+        try {
+            artifact = await readFixtureArtifact(projectRoot, caseEntry);
+        }
+        catch (err) {
+            verifierResults.push({
+                kind: "structural",
+                id: "structural:fixture:missing",
+                ok: false,
+                score: 0,
+                message: err instanceof Error ? err.message : String(err),
+                details: { fixture: caseEntry.fixture }
+            });
+        }
+        if (artifact !== undefined) {
+            const results = verifyStructural(artifact, structuralExpected);
+            if (results.length === 0) {
+                verifierResults.push(skeletonVerifierResult("Structural expectations parsed but produced zero checks.", { skipped: true }));
+            }
+            else {
+                verifierResults.push(...results);
+            }
+        }
+        else if (verifierResults.length === 0) {
+            verifierResults.push({
+                kind: "structural",
+                id: "structural:fixture:absent",
+                ok: false,
+                score: 0,
+                message: "Structural expectations declared but no fixture path provided. Add `fixture: ./<id>/fixture.md`.",
+                details: { fixtureProvided: false }
+            });
+        }
+    }
+    const allOk = verifierResults.every((r) => r.ok);
+    return {
+        caseId: caseEntry.id,
+        stage: caseEntry.stage,
+        tier: plannedTier,
+        passed: allOk,
+        durationMs: Date.now() - started,
+        verifierResults
+    };
+}
+function reduceSummary(caseResults) {
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let totalCostUsd = 0;
+    let totalDurationMs = 0;
+    for (const c of caseResults) {
+        totalDurationMs += c.durationMs;
+        if (c.costUsd !== undefined)
+            totalCostUsd += c.costUsd;
+        if (c.verifierResults.length === 1 && c.verifierResults[0]?.details?.skipped === true) {
+            skipped += 1;
+            continue;
+        }
+        if (c.passed)
+            passed += 1;
+        else
+            failed += 1;
+    }
+    return {
+        totalCases: caseResults.length,
+        passed,
+        failed,
+        skipped,
+        totalCostUsd: Number(totalCostUsd.toFixed(6)),
+        totalDurationMs
+    };
+}
+function stagesInResults(caseResults) {
+    const set = new Set();
+    for (const c of caseResults)
+        set.add(c.stage);
+    return FLOW_STAGES.filter((s) => set.has(s));
+}
 /**
- * Wave 7.0 runner. Responsibilities:
- * - Load resolved config (defaults + file + env).
- * - Load corpus (empty on a fresh install).
- * - Validate that no verifier flag asks for a capability that does not exist yet.
- * - Return either a dry-run summary or an empty report.
- *
- * Waves 7.1+ will replace the "no verifiers available" branch with the real
- * verifier dispatch pipeline. The signature stays stable so CLI wiring does
- * not churn.
+ * Structural runner. When `schemaOnly` is set (or no other verifier flags are
+ * active), runs structural verifiers against fixture-backed cases and loads
+ * per-stage baselines for regression comparison. Tier A/B/C agent loops
+ * arrive in later steps; until then cases without `fixture` are marked as
+ * skipped rather than failing.
  */
 export async function runEval(options) {
     const config = await loadEvalConfig(options.projectRoot, options.env ?? process.env);
@@ -25,16 +123,13 @@ export async function runEval(options) {
     const plannedTier = options.tier ?? config.defaultTier;
     const notes = [];
     if (corpus.length === 0) {
-        notes.push("Corpus is empty. Seed cases land in Wave 7.1 (`.cclaw/evals/corpus/<stage>/*.yaml`).");
-    }
-    if (options.schemaOnly) {
-        notes.push("--schema-only is accepted; structural verifiers wire up in Wave 7.1.");
+        notes.push("Corpus is empty. Seed cases live under `.cclaw/evals/corpus/<stage>/*.yaml`.");
     }
     if (options.rules) {
-        notes.push("--rules is accepted; rule verifiers wire up in Wave 7.2.");
+        notes.push("--rules is accepted; rule verifiers are not wired yet.");
     }
     if (options.judge) {
-        notes.push("--judge is accepted; LLM judging wires up in Wave 7.3.");
+        notes.push("--judge is accepted; LLM judging is not wired yet.");
     }
     if (options.dryRun === true) {
         const summary = {
@@ -47,7 +142,7 @@ export async function runEval(options) {
             },
             plannedTier,
             verifiersAvailable: {
-                structural: false,
+                structural: true,
                 rules: false,
                 judge: false,
                 workflow: false
@@ -57,22 +152,13 @@ export async function runEval(options) {
         return summary;
     }
     const now = new Date().toISOString();
-    const caseResults = corpus.map((item) => ({
-        caseId: item.id,
-        stage: item.stage,
-        tier: plannedTier,
-        passed: false,
-        durationMs: 0,
-        verifierResults: [
-            {
-                kind: "structural",
-                id: "wave-7-0-skeleton",
-                ok: false,
-                message: "Verifiers are not implemented in Wave 7.0; run with --dry-run.",
-                details: { skipped: true }
-            }
-        ]
-    }));
+    const caseResults = [];
+    for (const item of corpus) {
+        caseResults.push(await runCaseStructural(options.projectRoot, item, plannedTier));
+    }
+    const stages = stagesInResults(caseResults);
+    const baselines = await loadBaselinesByStage(options.projectRoot, stages);
+    const summary = reduceSummary(caseResults);
     const report = {
         schemaVersion: 1,
         generatedAt: now,
@@ -81,16 +167,12 @@ export async function runEval(options) {
         provider: config.provider,
         model: config.model,
         tier: plannedTier,
-        stages: options.stage ? [options.stage] : [],
+        stages,
         cases: caseResults,
-        summary: {
-            totalCases: caseResults.length,
-            passed: 0,
-            failed: 0,
-            skipped: caseResults.length,
-            totalCostUsd: 0,
-            totalDurationMs: 0
-        }
+        summary
     };
+    const baselineDelta = compareAgainstBaselines(report, baselines);
+    if (baselineDelta)
+        report.baselineDelta = baselineDelta;
     return report;
 }

package/dist/eval/types.d.ts

@@ -6,7 +6,7 @@
  * deliberately decoupled from the main cclaw runtime so that:
  *
  * - Users who never run `cclaw eval` pay zero runtime cost.
- * - The verifier / rubric / LLM stack evolves on its own release cadence (Waves 7.0-7.6).
+ * - The verifier / rubric / LLM stack evolves on its own release cadence (Steps 0-6).
  * - Any OpenAI-compatible endpoint can be swapped in via config (z.ai, OpenAI, vLLM, etc.).
  */
 import type { FlowStage } from "../types.js";
@@ -27,11 +27,50 @@ export type EvalTier = (typeof EVAL_TIERS)[number];
  */
 export declare const VERIFIER_KINDS: readonly ["structural", "rules", "judge", "workflow"];
 export type VerifierKind = (typeof VERIFIER_KINDS)[number];
+/**
+ * Structural expectations — deterministic, LLM-free checks against a single
+ * text artifact. Step 1 implements all fields below; Step 2 adds the
+ * sibling `rules` shape, Step 3 adds `judge`.
+ */
+export interface StructuralExpected {
+    /**
+     * Case-insensitive substrings that must each appear on at least one markdown
+     * heading line (line starting with `#`). Useful for "required sections".
+     */
+    requiredSections?: string[];
+    /**
+     * Case-insensitive substrings that must NOT appear anywhere in the body
+     * (headings or prose). Typical entries: "TBD", "TODO", "placeholder".
+     */
+    forbiddenPatterns?: string[];
+    /** Inclusive minimum line count of the artifact body (frontmatter excluded). */
+    minLines?: number;
+    /** Inclusive maximum line count of the artifact body (frontmatter excluded). */
+    maxLines?: number;
+    /** Inclusive minimum character count of the artifact body. */
+    minChars?: number;
+    /** Inclusive maximum character count of the artifact body. */
+    maxChars?: number;
+    /**
+     * Keys that must appear in the leading YAML frontmatter (between a pair of
+     * `---` delimiters at the very top of the file). An artifact without
+     * frontmatter will fail every entry.
+     */
+    requiredFrontmatterKeys?: string[];
+}
+/** Superset of per-verifier expectation shapes. Only `structural` is wired in Step 1. */
+export interface ExpectedShape {
+    structural?: StructuralExpected;
+    /** Rule-based (keyword/regex/traceability) checks — Step 2. */
+    rules?: Record<string, unknown>;
+    /** LLM-judge rubrics — Step 3. */
+    judge?: Record<string, unknown>;
+}
 /**
  * A single eval case describes one input scenario for one stage. Cases live in
  * `.cclaw/evals/corpus/<stage>/<id>.yaml` and may reference a pre-generated
- * fixture artifact for verifier development (Wave 7.1) before the agent loop
- * exists (Wave 7.3+).
+ * fixture artifact for verifier development (Step 1) before the agent loop
+ * exists (Step 3+).
  */
 export interface EvalCase {
     id: string;
@@ -40,14 +79,14 @@ export interface EvalCase {
     /** Project files copied into the Tier B/C sandbox before the agent runs. */
     contextFiles?: string[];
     /**
-     * Optional expected-shape hints consumed by structural/rule verifiers.
-     * Left intentionally loose; verifiers in Waves 7.1–7.2 will narrow this.
+     * Typed expectation hints consumed by the structural/rules/judge verifiers.
+     * Each sub-shape is optional; missing sub-shapes skip that verifier tier.
      */
-    expected?: Record<string, unknown>;
+    expected?: ExpectedShape;
     /**
      * Path (relative to the corpus case file) of a pre-generated artifact used
-     * when verifiers are exercised without a live agent loop. Primarily a Wave
-     * 7.1 development aid.
+     * when verifiers are exercised without a live agent loop. Primarily a
+     * Step 1 development aid.
      */
     fixture?: string;
 }
@@ -90,12 +129,8 @@ export interface EvalReport {
         totalCostUsd: number;
         totalDurationMs: number;
     };
-    /** Present when comparing against a saved baseline (Wave 7.1+). */
-    baselineDelta?: {
-        baselineId: string;
-        scoreDelta: number;
-        criticalFailures: number;
-    };
+    /** Present when comparing against a saved baseline (Step 1+). */
+    baselineDelta?: BaselineDelta;
 }
 /**
  * Eval configuration, persisted to `.cclaw/evals/config.yaml` and mergeable
@@ -134,3 +169,48 @@ export interface ResolvedEvalConfig extends EvalConfig {
     apiKey?: string;
     source: "default" | "file" | "env" | "file+env";
 }
+/**
+ * Frozen per-stage baseline used by regression gating (Step 1). Baselines
+ * are committed to git; `cclaw eval --update-baseline --confirm` rewrites
+ * them. The shape is intentionally flat so a quick `git diff` reveals what
+ * changed between runs.
+ */
+export interface BaselineSnapshot {
+    schemaVersion: 1;
+    stage: FlowStage;
+    generatedAt: string;
+    cclawVersion: string;
+    /** Keyed by `EvalCase.id` so unchanged cases produce zero diff. */
+    cases: Record<string, BaselineCaseEntry>;
+}
+export interface BaselineCaseEntry {
+    passed: boolean;
+    verifierResults: BaselineVerifierEntry[];
+}
+export interface BaselineVerifierEntry {
+    id: string;
+    kind: VerifierKind;
+    ok: boolean;
+    score?: number;
+}
+/**
+ * Delta between a fresh report and the saved baseline. Populated when
+ * baselines exist on disk and the run covers matching cases.
+ */
+export interface BaselineDelta {
+    baselineId: string;
+    /** Fresh-score − baseline-score, bounded to [-1, 1]. */
+    scoreDelta: number;
+    /** Count of checks that flipped from `ok:true` to `ok:false`. */
+    criticalFailures: number;
+    /** Per-case regression details for the Markdown report. */
+    regressions: BaselineRegression[];
+}
+export interface BaselineRegression {
+    caseId: string;
+    stage: FlowStage;
+    verifierId: string;
+    reason: "newly-failing" | "case-now-failing" | "score-drop";
+    previousScore?: number;
+    currentScore?: number;
+}

package/dist/eval/verifiers/structural.d.ts

@@ -0,0 +1,14 @@
+import type { StructuralExpected, VerifierResult } from "../types.js";
+export interface ArtifactSplit {
+    hasFrontmatter: boolean;
+    frontmatterRaw: string;
+    frontmatterParsed?: Record<string, unknown>;
+    body: string;
+}
+export declare function splitFrontmatter(artifact: string): ArtifactSplit;
+/**
+ * Run every configured structural check against the artifact text.
+ * Returns [] when `expected` is undefined/empty so the runner can treat
+ * "no structural expectations" as "no verifier results" rather than "pass".
+ */
+export declare function verifyStructural(artifact: string, expected: StructuralExpected | undefined): VerifierResult[];

package/dist/eval/verifiers/structural.js

@@ -0,0 +1,171 @@
+/**
+ * Structural verifier: deterministic, zero-LLM checks against a
+ * single markdown artifact. Each structural expectation produces one
+ * `VerifierResult` so baselines diff cleanly at the check level rather than
+ * lumping everything into a single boolean.
+ *
+ * Design notes:
+ *
+ * - All pattern matching is case-insensitive. Authoring a check as
+ *   `"Directions"` matches `## Directions` and `### directions-suggested`.
+ * - Frontmatter detection is permissive: it must start at byte 0 with `---\n`
+ *   and close on a subsequent `---` line. Anything else is treated as "no
+ *   frontmatter", which fails every `requiredFrontmatterKeys` entry
+ *   deterministically.
+ * - `minLines`/`maxLines` intentionally exclude frontmatter so a rewrite that
+ *   adds metadata does not accidentally drop the body below the floor.
+ * - Scoring: each check scores 0 or 1. The case `passed` becomes the AND of
+ *   all individual `ok` flags. This keeps the structural verifier
+ *   deterministic; the 0..1 rubric scale shows up later in the LLM judge.
+ */
+import { parse as parseYaml } from "yaml";
+const FRONTMATTER_OPEN = /^---\r?\n/;
+const FRONTMATTER_CLOSE = /\r?\n---\r?(?:\n|$)/;
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "")
+        .slice(0, 64);
+}
+export function splitFrontmatter(artifact) {
+    if (!FRONTMATTER_OPEN.test(artifact)) {
+        return { hasFrontmatter: false, frontmatterRaw: "", body: artifact };
+    }
+    const afterOpen = artifact.replace(FRONTMATTER_OPEN, "");
+    const closeMatch = afterOpen.match(FRONTMATTER_CLOSE);
+    if (!closeMatch || closeMatch.index === undefined) {
+        return { hasFrontmatter: false, frontmatterRaw: "", body: artifact };
+    }
+    const frontmatterRaw = afterOpen.slice(0, closeMatch.index);
+    const body = afterOpen.slice(closeMatch.index + closeMatch[0].length);
+    let frontmatterParsed;
+    try {
+        const parsed = parseYaml(frontmatterRaw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            frontmatterParsed = parsed;
+        }
+    }
+    catch {
+        frontmatterParsed = undefined;
+    }
+    return {
+        hasFrontmatter: true,
+        frontmatterRaw,
+        frontmatterParsed,
+        body
+    };
+}
+function extractHeadingLines(body) {
+    return body
+        .split(/\r?\n/)
+        .map((line) => line.trimStart())
+        .filter((line) => /^#{1,6}\s+\S/.test(line));
+}
+function result(id, ok, message, details) {
+    return {
+        kind: "structural",
+        id,
+        ok,
+        score: ok ? 1 : 0,
+        message,
+        ...(details !== undefined ? { details } : {})
+    };
+}
+function checkRequiredSections(sections, body) {
+    const headings = extractHeadingLines(body).map((line) => line.toLowerCase());
+    return sections.map((section) => {
+        const needle = section.toLowerCase().trim();
+        const found = headings.some((heading) => heading.includes(needle));
+        return result(`structural:section:${slugify(section)}`, found, found
+            ? `Section matching "${section}" present.`
+            : `No heading contains "${section}".`, { pattern: section, searchedHeadings: headings.length });
+    });
+}
+function checkForbiddenPatterns(patterns, body) {
+    const bodyLower = body.toLowerCase();
+    return patterns.map((pattern) => {
+        const needle = pattern.toLowerCase();
+        const hits = countOccurrences(bodyLower, needle);
+        const ok = hits === 0;
+        return result(`structural:forbidden:${slugify(pattern)}`, ok, ok
+            ? `Pattern "${pattern}" absent (as required).`
+            : `Pattern "${pattern}" appears ${hits} time(s); remove.`, { pattern, occurrences: hits });
+    });
+}
+function countOccurrences(haystack, needle) {
+    if (needle.length === 0)
+        return 0;
+    let index = 0;
+    let count = 0;
+    while (true) {
+        const at = haystack.indexOf(needle, index);
+        if (at < 0)
+            return count;
+        count += 1;
+        index = at + needle.length;
+    }
+}
+function checkLengthBounds(expected, body) {
+    const results = [];
+    const lineCount = body.length === 0 ? 0 : body.split(/\r?\n/).length;
+    const charCount = body.length;
+    if (expected.minLines !== undefined || expected.maxLines !== undefined) {
+        const min = expected.minLines;
+        const max = expected.maxLines;
+        const withinMin = min === undefined || lineCount >= min;
+        const withinMax = max === undefined || lineCount <= max;
+        const ok = withinMin && withinMax;
+        results.push(result("structural:length:lines", ok, ok
+            ? `Body has ${lineCount} line(s), within bounds.`
+            : buildOutOfRangeMessage("line", lineCount, min, max), { lineCount, minLines: min, maxLines: max }));
+    }
+    if (expected.minChars !== undefined || expected.maxChars !== undefined) {
+        const min = expected.minChars;
+        const max = expected.maxChars;
+        const withinMin = min === undefined || charCount >= min;
+        const withinMax = max === undefined || charCount <= max;
+        const ok = withinMin && withinMax;
+        results.push(result("structural:length:chars", ok, ok
+            ? `Body has ${charCount} char(s), within bounds.`
+            : buildOutOfRangeMessage("char", charCount, min, max), { charCount, minChars: min, maxChars: max }));
+    }
+    return results;
+}
+function buildOutOfRangeMessage(unit, actual, min, max) {
+    const lo = min === undefined ? "0" : String(min);
+    const hi = max === undefined ? "∞" : String(max);
+    return `Body has ${actual} ${unit}(s); expected ${lo}..${hi}.`;
+}
+function checkFrontmatterKeys(keys, split) {
+    if (!split.hasFrontmatter || !split.frontmatterParsed) {
+        return keys.map((key) => result(`structural:frontmatter:${slugify(key)}`, false, `Frontmatter key "${key}" missing (no parseable frontmatter).`, { key, frontmatterPresent: split.hasFrontmatter }));
+    }
+    const present = new Set(Object.keys(split.frontmatterParsed));
+    return keys.map((key) => {
+        const ok = present.has(key);
+        return result(`structural:frontmatter:${slugify(key)}`, ok, ok ? `Frontmatter key "${key}" present.` : `Frontmatter key "${key}" missing.`, { key });
+    });
+}
+/**
+ * Run every configured structural check against the artifact text.
+ * Returns [] when `expected` is undefined/empty so the runner can treat
+ * "no structural expectations" as "no verifier results" rather than "pass".
+ */
+export function verifyStructural(artifact, expected) {
+    if (!expected)
+        return [];
+    const split = splitFrontmatter(artifact);
+    const results = [];
+    if (expected.requiredSections?.length) {
+        results.push(...checkRequiredSections(expected.requiredSections, split.body));
+    }
+    if (expected.forbiddenPatterns?.length) {
+        results.push(...checkForbiddenPatterns(expected.forbiddenPatterns, split.body));
+    }
+    results.push(...checkLengthBounds(expected, split.body));
+    if (expected.requiredFrontmatterKeys?.length) {
+        results.push(...checkFrontmatterKeys(expected.requiredFrontmatterKeys, split));
+    }
+    return results;
+}

package/dist/install.js

@@ -29,7 +29,7 @@ import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.j
 import { decisionProtocolMarkdown, completionProtocolMarkdown, ethosProtocolMarkdown } from "./content/protocols.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { EVAL_BASELINES_README, EVAL_CONFIG_YAML, EVAL_CORPUS_README, EVAL_REPORTS_README, EVAL_RUBRICS_README } from "./content/eval-scaffold.js";
-import { TDD_WAVE_WALKTHROUGH_MARKDOWN, stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
+import { TDD_BATCH_WALKTHROUGH_MARKDOWN, stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
 import { stageCommonGuidanceMarkdown } from "./content/stage-common-guidance.js";
 import { STAGE_EXAMPLES_REFERENCE_DIR, stageExamplesReferenceMarkdown } from "./content/examples.js";
 import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LANGUAGE_RULE_PACK_GENERATORS, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
@@ -218,11 +218,11 @@ async function writeSkills(projectRoot, config) {
             await writeFileSafe(runtimePath(projectRoot, ...referenceDir, `${stage}-examples.md`), referenceMarkdown);
         }
     }
-    // Progressive disclosure for the TDD Wave Execution walkthrough (A.1#1).
+    // Progressive disclosure for the TDD Batch Execution walkthrough (A.1#1).
     // The detailed 3-task transcript lives next to stage examples so the
     // always-rendered TDD skill stays under the line-budget and the reference
     // is loaded on demand.
-    await writeFileSafe(runtimePath(projectRoot, ...STAGE_EXAMPLES_REFERENCE_DIR.split("/"), "tdd-wave-walkthrough.md"), TDD_WAVE_WALKTHROUGH_MARKDOWN);
+    await writeFileSafe(runtimePath(projectRoot, ...STAGE_EXAMPLES_REFERENCE_DIR.split("/"), "tdd-batch-walkthrough.md"), TDD_BATCH_WALKTHROUGH_MARKDOWN);
     await writeFileSafe(runtimePath(projectRoot, ...STAGE_EXAMPLES_REFERENCE_DIR.split("/"), "common-guidance.md"), stageCommonGuidanceMarkdown());
     // Utility skills (not flow stages)
     await writeFileSafe(runtimePath(projectRoot, "skills", "learnings", "SKILL.md"), learnSkillMarkdown());

package/dist/policy.js

@@ -161,7 +161,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/docs/SKILL.md"), needle: "## README Guidance", name: "utility_skill:docs:readme" },
         { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:executing_plans:hard_gate" },
         { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Execution Protocol", name: "utility_skill:executing_plans:protocol" },
-        { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Wave Checklist", name: "utility_skill:executing_plans:waves" },
+        { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Batch Checklist", name: "utility_skill:executing_plans:batches" },
         { file: runtimeFile("skills/verification-before-completion/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:verification_before_completion:hard_gate" },
         { file: runtimeFile("skills/verification-before-completion/SKILL.md"), needle: "## Protocol", name: "utility_skill:verification_before_completion:protocol" },
         { file: runtimeFile("skills/finishing-a-development-branch/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:finishing_branch:hard_gate" },

package/package.json

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