cclaw-cli 0.23.0 → 0.24.0

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";
@@ -29,8 +29,8 @@ export declare const VERIFIER_KINDS: readonly ["structural", "rules", "judge", "
 export type VerifierKind = (typeof VERIFIER_KINDS)[number];
 /**
  * Structural expectations — deterministic, LLM-free checks against a single
- * text artifact. Wave 7.1 implements all fields below; Wave 7.2 adds the
- * sibling `rules` shape, Wave 7.3 adds `judge`.
+ * text artifact. Step 1 implements all fields below; Step 2 adds the
+ * sibling `rules` shape, Step 3 adds `judge`.
  */
 export interface StructuralExpected {
     /**
@@ -58,19 +58,77 @@ export interface StructuralExpected {
      */
     requiredFrontmatterKeys?: string[];
 }
-/** Superset of per-verifier expectation shapes. Only `structural` is wired in Wave 7.1. */
+/**
+ * Rule-based expectations — zero-LLM content checks that are richer than
+ * structural (regex, numeric bounds, uniqueness). Introduced in Step 2.
+ *
+ * Every array field is optional; an empty `RulesExpected` produces zero
+ * verifier results so authors can enable rules incrementally.
+ */
+export interface RulesExpected {
+    /** Case-insensitive substrings the body must include at least once. */
+    mustContain?: string[];
+    /** Case-insensitive substrings the body must NOT include. */
+    mustNotContain?: string[];
+    /** Regex patterns that must match the body at least once. */
+    regexRequired?: RuleRegex[];
+    /** Regex patterns that must NOT match the body. */
+    regexForbidden?: RuleRegex[];
+    /** For each substring key, the body must contain at least N occurrences. */
+    minOccurrences?: Record<string, number>;
+    /** For each substring key, the body must contain at most N occurrences. */
+    maxOccurrences?: Record<string, number>;
+    /**
+     * For each named section (case-insensitive heading substring), every bullet
+     * (`- ...`) directly under the section must be unique. Catches duplicated
+     * decisions or repeated risks.
+     */
+    uniqueBulletsInSection?: string[];
+}
+export interface RuleRegex {
+    /** Source of the regex. Parsed with `new RegExp(pattern, flags)`. */
+    pattern: string;
+    /** Optional regex flags; defaults to `"i"` for case-insensitive matching. */
+    flags?: string;
+    /** Human-readable label rendered in verifier messages and slugged into the id. */
+    description?: string;
+}
+/**
+ * Cross-stage traceability expectations — assert every ID extracted from
+ * `source` also appears in `self` and/or named `extra_fixtures`. Introduced
+ * in Step 2.
+ */
+export interface TraceabilityExpected {
+    /** Regex applied to the `source` fixture to collect the authoritative ID set. */
+    idPattern: string;
+    /** Optional regex flags (defaults to `"g"`). */
+    idFlags?: string;
+    /**
+     * Where to read the authoritative ID set from. Either `"self"` (the case's
+     * primary `fixture`) or a label present in the case's `extraFixtures` map.
+     */
+    source: string;
+    /**
+     * Where every source ID must also appear. Each entry is `"self"` or an
+     * `extraFixtures` label. Order is preserved for deterministic result ids.
+     */
+    requireIn: string[];
+}
+/** Superset of per-verifier expectation shapes. */
 export interface ExpectedShape {
     structural?: StructuralExpected;
-    /** Rule-based (keyword/regex/traceability) checks — Wave 7.2. */
-    rules?: Record<string, unknown>;
-    /** LLM-judge rubrics — Wave 7.3. */
+    /** Rule-based (keyword/regex/count/uniqueness) checks — Step 2. */
+    rules?: RulesExpected;
+    /** Cross-stage ID propagation checks — Step 2. */
+    traceability?: TraceabilityExpected;
+    /** 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;
@@ -85,10 +143,17 @@ export interface EvalCase {
     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;
+    /**
+     * Additional fixture paths loaded alongside the primary `fixture`, keyed
+     * by a free-form label. Consumed by cross-artifact verifiers (e.g.,
+     * traceability) introduced in Step 2. Paths are resolved relative to the
+     * case's stage directory, just like `fixture`.
+     */
+    extraFixtures?: Record<string, string>;
 }
 /** Result of one verifier applied to one case. */
 export interface VerifierResult {
@@ -129,7 +194,7 @@ export interface EvalReport {
         totalCostUsd: number;
         totalDurationMs: number;
     };
-    /** Present when comparing against a saved baseline (Wave 7.1+). */
+    /** Present when comparing against a saved baseline (Step 1+). */
     baselineDelta?: BaselineDelta;
 }
 /**
@@ -170,7 +235,7 @@ export interface ResolvedEvalConfig extends EvalConfig {
     source: "default" | "file" | "env" | "file+env";
 }
 /**
- * Frozen per-stage baseline used by regression gating (Wave 7.1). Baselines
+ * 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.

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

@@ -0,0 +1,24 @@
+/**
+ * Rule-based verifier: deterministic, zero-LLM checks that are richer than
+ * structural heading/length assertions. Each rule produces exactly one
+ * `VerifierResult` so baselines diff at the check level, and authoring a
+ * rule sideways in YAML never silently skips.
+ *
+ * Semantics:
+ *
+ * - All substring matching is case-insensitive. Regex matching uses the
+ *   flags declared on the rule (default `"i"`).
+ * - Rules operate on the artifact BODY (frontmatter stripped), mirroring
+ *   the structural verifier so min/max counts and length checks agree on
+ *   what "body" means.
+ * - `uniqueBulletsInSection` scans every section (heading, case-insensitive
+ *   substring match) and flags duplicate top-level bullets ("- item"). The
+ *   search stops at the next heading of equal or lower depth.
+ */
+import type { RulesExpected, VerifierResult } from "../types.js";
+/**
+ * Run every configured rule check against the artifact body. Returns `[]`
+ * when `expected` is undefined or empty so the runner can distinguish
+ * "no rules declared" from "all rules passed".
+ */
+export declare function verifyRules(artifact: string, expected: RulesExpected | undefined): VerifierResult[];

package/dist/eval/verifiers/rules.js

@@ -0,0 +1,218 @@
+import { splitFrontmatter } from "./structural.js";
+function slugify(input) {
+    return (input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "")
+        .slice(0, 64) || "rule");
+}
+function result(id, ok, message, details) {
+    return {
+        kind: "rules",
+        id,
+        ok,
+        score: ok ? 1 : 0,
+        message,
+        ...(details !== undefined ? { details } : {})
+    };
+}
+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 compileRegex(rule) {
+    const flags = rule.flags ?? "i";
+    try {
+        return new RegExp(rule.pattern, flags);
+    }
+    catch (err) {
+        throw new Error(`Invalid regex for rule "${rule.description ?? rule.pattern}" ` +
+            `(pattern=${JSON.stringify(rule.pattern)}, flags=${JSON.stringify(flags)}): ` +
+            (err instanceof Error ? err.message : String(err)));
+    }
+}
+function ruleLabel(rule) {
+    return rule.description?.trim() || rule.pattern;
+}
+function checkMustContain(needles, body) {
+    const bodyLower = body.toLowerCase();
+    return needles.map((needle) => {
+        const found = bodyLower.includes(needle.toLowerCase());
+        return result(`rules:contains:${slugify(needle)}`, found, found
+            ? `Required phrase "${needle}" present.`
+            : `Required phrase "${needle}" missing from body.`, { phrase: needle });
+    });
+}
+function checkMustNotContain(needles, body) {
+    const bodyLower = body.toLowerCase();
+    return needles.map((needle) => {
+        const lowered = needle.toLowerCase();
+        const occurrences = countOccurrences(bodyLower, lowered);
+        const ok = occurrences === 0;
+        return result(`rules:not-contains:${slugify(needle)}`, ok, ok
+            ? `Forbidden phrase "${needle}" absent (as required).`
+            : `Forbidden phrase "${needle}" appears ${occurrences} time(s).`, { phrase: needle, occurrences });
+    });
+}
+function checkRegexRequired(rules, body) {
+    return rules.map((rule) => {
+        const label = ruleLabel(rule);
+        const regex = compileRegex(rule);
+        const matches = body.match(new RegExp(regex.source, withGlobal(regex.flags)));
+        const count = matches ? matches.length : 0;
+        const ok = count > 0;
+        return result(`rules:regex-required:${slugify(label)}`, ok, ok
+            ? `Required pattern /${rule.pattern}/ matched ${count} time(s).`
+            : `Required pattern /${rule.pattern}/ did not match.`, { pattern: rule.pattern, flags: rule.flags ?? "i", matches: count });
+    });
+}
+function checkRegexForbidden(rules, body) {
+    return rules.map((rule) => {
+        const label = ruleLabel(rule);
+        const regex = compileRegex(rule);
+        const matches = body.match(new RegExp(regex.source, withGlobal(regex.flags)));
+        const count = matches ? matches.length : 0;
+        const ok = count === 0;
+        return result(`rules:regex-forbidden:${slugify(label)}`, ok, ok
+            ? `Forbidden pattern /${rule.pattern}/ absent.`
+            : `Forbidden pattern /${rule.pattern}/ matched ${count} time(s).`, { pattern: rule.pattern, flags: rule.flags ?? "i", matches: count });
+    });
+}
+function withGlobal(flags) {
+    return flags.includes("g") ? flags : `${flags}g`;
+}
+function checkMinOccurrences(bounds, body) {
+    const bodyLower = body.toLowerCase();
+    return Object.entries(bounds).map(([needle, min]) => {
+        const occurrences = countOccurrences(bodyLower, needle.toLowerCase());
+        const ok = occurrences >= min;
+        return result(`rules:min-occurrences:${slugify(needle)}`, ok, ok
+            ? `Phrase "${needle}" appears ${occurrences} time(s) (>= ${min}).`
+            : `Phrase "${needle}" appears ${occurrences} time(s); expected at least ${min}.`, { phrase: needle, occurrences, min });
+    });
+}
+function checkMaxOccurrences(bounds, body) {
+    const bodyLower = body.toLowerCase();
+    return Object.entries(bounds).map(([needle, max]) => {
+        const occurrences = countOccurrences(bodyLower, needle.toLowerCase());
+        const ok = occurrences <= max;
+        return result(`rules:max-occurrences:${slugify(needle)}`, ok, ok
+            ? `Phrase "${needle}" appears ${occurrences} time(s) (<= ${max}).`
+            : `Phrase "${needle}" appears ${occurrences} time(s); expected at most ${max}.`, { phrase: needle, occurrences, max });
+    });
+}
+function sliceBySection(body) {
+    const lines = body.split(/\r?\n/);
+    const slices = [];
+    let current = null;
+    for (const rawLine of lines) {
+        const line = rawLine.trimStart();
+        const match = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+        if (match) {
+            if (current) {
+                slices.push({
+                    heading: current.heading,
+                    depth: current.depth,
+                    body: current.body.join("\n")
+                });
+            }
+            current = { heading: match[2].trim(), depth: match[1].length, body: [] };
+        }
+        else if (current) {
+            current.body.push(rawLine);
+        }
+    }
+    if (current) {
+        slices.push({
+            heading: current.heading,
+            depth: current.depth,
+            body: current.body.join("\n")
+        });
+    }
+    return slices;
+}
+function extractTopLevelBullets(sectionBody) {
+    const bullets = [];
+    for (const rawLine of sectionBody.split(/\r?\n/)) {
+        const line = rawLine.replace(/\s+$/, "");
+        const leading = line.match(/^(\s*)[-*]\s+(.+)$/);
+        if (!leading)
+            continue;
+        if (leading[1].length > 0)
+            continue;
+        bullets.push(leading[2].trim());
+    }
+    return bullets;
+}
+function checkUniqueBulletsInSection(sections, body) {
+    const slices = sliceBySection(body);
+    return sections.map((needle) => {
+        const lowerNeedle = needle.toLowerCase();
+        const slice = slices.find((s) => s.heading.toLowerCase().includes(lowerNeedle));
+        if (!slice) {
+            return result(`rules:unique-in-section:${slugify(needle)}`, false, `Section matching "${needle}" not found; cannot check uniqueness.`, { section: needle, found: false });
+        }
+        const bullets = extractTopLevelBullets(slice.body);
+        const seen = new Map();
+        for (const bullet of bullets) {
+            const key = bullet.toLowerCase();
+            seen.set(key, (seen.get(key) ?? 0) + 1);
+        }
+        const duplicates = [...seen.entries()]
+            .filter(([, count]) => count > 1)
+            .map(([entry, count]) => ({ entry, count }));
+        const ok = duplicates.length === 0;
+        return result(`rules:unique-in-section:${slugify(needle)}`, ok, ok
+            ? `Section "${slice.heading}" has ${bullets.length} unique bullet(s).`
+            : `Section "${slice.heading}" has duplicate bullet(s): ${duplicates
+                .map((d) => `"${d.entry}" x${d.count}`)
+                .join(", ")}.`, {
+            section: slice.heading,
+            bullets: bullets.length,
+            duplicates
+        });
+    });
+}
+/**
+ * Run every configured rule check against the artifact body. Returns `[]`
+ * when `expected` is undefined or empty so the runner can distinguish
+ * "no rules declared" from "all rules passed".
+ */
+export function verifyRules(artifact, expected) {
+    if (!expected)
+        return [];
+    const split = splitFrontmatter(artifact);
+    const body = split.body;
+    const results = [];
+    if (expected.mustContain?.length) {
+        results.push(...checkMustContain(expected.mustContain, body));
+    }
+    if (expected.mustNotContain?.length) {
+        results.push(...checkMustNotContain(expected.mustNotContain, body));
+    }
+    if (expected.regexRequired?.length) {
+        results.push(...checkRegexRequired(expected.regexRequired, body));
+    }
+    if (expected.regexForbidden?.length) {
+        results.push(...checkRegexForbidden(expected.regexForbidden, body));
+    }
+    if (expected.minOccurrences && Object.keys(expected.minOccurrences).length) {
+        results.push(...checkMinOccurrences(expected.minOccurrences, body));
+    }
+    if (expected.maxOccurrences && Object.keys(expected.maxOccurrences).length) {
+        results.push(...checkMaxOccurrences(expected.maxOccurrences, body));
+    }
+    if (expected.uniqueBulletsInSection?.length) {
+        results.push(...checkUniqueBulletsInSection(expected.uniqueBulletsInSection, body));
+    }
+    return results;
+}

package/dist/eval/verifiers/structural.js

@@ -1,5 +1,5 @@
 /**
- * Structural verifier (Wave 7.1): deterministic, zero-LLM checks against a
+ * 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.
@@ -15,8 +15,8 @@
  * - `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 Wave 7.1 deterministic; the 0..1
- *   rubric scale shows up in Wave 7.3 (judge).
+ *   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/;

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

@@ -0,0 +1,23 @@
+/**
+ * Cross-stage traceability verifier: extract a set of IDs from a source
+ * fixture (e.g. `D-\d+` decisions declared during scope) and assert every
+ * ID appears in the artifact-under-test and/or in other linked fixtures.
+ *
+ * The verifier is intentionally source-agnostic: the caller passes the
+ * primary artifact plus a label → text map for any extra fixtures declared
+ * on the case. `source` and entries in `requireIn` are either the string
+ * `"self"` (the primary artifact) or labels present in the extras map.
+ *
+ * Result ids follow `traceability:<source>->:<target>:<reason>` so baselines
+ * diff at the per-link granularity. A missing link produces one result with
+ * a list of missing IDs in its `details` payload.
+ */
+import type { TraceabilityExpected, VerifierResult } from "../types.js";
+export declare const SELF_LABEL = "self";
+/**
+ * Run traceability checks. Returns `[]` when expectations are undefined.
+ * Emits a single "source-missing" result when the declared source fixture
+ * has zero IDs (authoring error), and one result per `requireIn` target
+ * listing any IDs absent in that fixture.
+ */
+export declare function verifyTraceability(primaryArtifact: string, extraFixtures: Record<string, string>, expected: TraceabilityExpected | undefined): VerifierResult[];

package/dist/eval/verifiers/traceability.js

@@ -0,0 +1,84 @@
+import { splitFrontmatter } from "./structural.js";
+export const SELF_LABEL = "self";
+function result(id, ok, message, details) {
+    return {
+        kind: "rules",
+        id,
+        ok,
+        score: ok ? 1 : 0,
+        message,
+        ...(details !== undefined ? { details } : {})
+    };
+}
+function compileIdRegex(expected) {
+    const flags = expected.idFlags ?? "g";
+    const normalized = flags.includes("g") ? flags : `${flags}g`;
+    try {
+        return new RegExp(expected.idPattern, normalized);
+    }
+    catch (err) {
+        throw new Error(`Invalid traceability id_pattern ${JSON.stringify(expected.idPattern)} ` +
+            `(flags=${JSON.stringify(normalized)}): ` +
+            (err instanceof Error ? err.message : String(err)));
+    }
+}
+function bodyOf(text) {
+    return splitFrontmatter(text).body;
+}
+function extractIds(text, regex) {
+    const body = bodyOf(text);
+    const found = new Set();
+    for (const match of body.matchAll(regex)) {
+        found.add(match[0]);
+    }
+    return [...found].sort();
+}
+function resolveFixture(label, primary, extraFixtures) {
+    if (label === SELF_LABEL)
+        return primary;
+    return extraFixtures[label];
+}
+/**
+ * Run traceability checks. Returns `[]` when expectations are undefined.
+ * Emits a single "source-missing" result when the declared source fixture
+ * has zero IDs (authoring error), and one result per `requireIn` target
+ * listing any IDs absent in that fixture.
+ */
+export function verifyTraceability(primaryArtifact, extraFixtures, expected) {
+    if (!expected)
+        return [];
+    const regex = compileIdRegex(expected);
+    const sourceText = resolveFixture(expected.source, primaryArtifact, extraFixtures);
+    if (sourceText === undefined) {
+        return [
+            result(`traceability:source:${expected.source}:missing`, false, `Traceability source fixture "${expected.source}" not loaded.`, { source: expected.source })
+        ];
+    }
+    const sourceIds = extractIds(sourceText, regex);
+    if (sourceIds.length === 0) {
+        return [
+            result(`traceability:source:${expected.source}:empty`, false, `Source "${expected.source}" yielded zero ids for pattern /${expected.idPattern}/.`, { source: expected.source, pattern: expected.idPattern })
+        ];
+    }
+    const results = [];
+    for (const target of expected.requireIn) {
+        const targetText = resolveFixture(target, primaryArtifact, extraFixtures);
+        if (targetText === undefined) {
+            results.push(result(`traceability:target:${target}:missing`, false, `Traceability target fixture "${target}" not loaded.`, { target }));
+            continue;
+        }
+        const targetBody = bodyOf(targetText);
+        const missing = sourceIds.filter((id) => !targetBody.includes(id));
+        const ok = missing.length === 0;
+        results.push(result(`traceability:${expected.source}->${target}`, ok, ok
+            ? `Every id (${sourceIds.length}) from "${expected.source}" appears in "${target}".`
+            : `Target "${target}" is missing ${missing.length}/${sourceIds.length} id(s): ${missing.join(", ")}.`, {
+            source: expected.source,
+            target,
+            sourceIds,
+            missing,
+            pattern: expected.idPattern
+        }));
+    }
+    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.23.0",
+  "version": "0.24.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {