cclaw-cli 0.23.0 → 0.24.0

package/dist/content/utility-skills.js

@@ -482,7 +482,7 @@ description: "Execute approved plans with disciplined batching, explicit checkpo
 ## Quick Start
 
 > 1. Confirm the plan and stage gates are approved before execution.
-> 2. Execute in batches (waves), not as one giant untracked stream.
+> 2. Execute in batches, not as one giant untracked stream.
 > 3. Stop at checkpoint boundaries for verification and user visibility.
 
 ## HARD-GATE
@@ -492,47 +492,47 @@ Do not start implementation execution without an approved plan artifact and expl
 ## Execution Protocol
 
 1. **Load plan source of truth** from \`.cclaw/artifacts/05-plan.md\` (canonical run copy when available).
-2. **Group tasks into waves** by dependency order and risk.
-3. **Run one wave at a time** with evidence after each task (tests, build, lint, or review evidence as applicable).
-4. **Checkpoint each wave** by updating stage artifact evidence and unresolved blockers.
+2. **Group tasks into batches** by dependency order and risk.
+3. **Run one batch at a time** with evidence after each task (tests, build, lint, or review evidence as applicable).
+4. **Checkpoint each batch** by updating stage artifact evidence and unresolved blockers.
 5. **Stop immediately** on any hard blocker, failing gate, or unresolved critical finding.
 
-## Wave Checklist
+## Batch Checklist
 
-- Wave scope is explicit (task IDs + expected outputs).
+- Batch scope is explicit (task IDs + expected outputs).
 - Verification command for each task is predetermined.
 - Machine-only checks are delegated to subagents when supported.
 - User approvals are requested only at required gate boundaries.
 
-## Fresh Context Protocol (between waves)
+## Fresh Context Protocol (between batches)
 
-After a wave completes — especially after long agent turns — context drift is
-the #1 cause of degraded execution quality. Before starting the **next wave**,
+After a batch completes — especially after long agent turns — context drift is
+the #1 cause of degraded execution quality. Before starting the **next batch**,
 prefer a **fresh agent context** over continuing in a saturated session:
 
-1. **Snapshot wave outcome** — append a short summary to the plan artifact
-   (\`### Wave <N> outcome\` with: tasks done, evidence files, blockers, next-wave inputs).
+1. **Snapshot batch outcome** — append a short summary to the plan artifact
+   (\`### Batch <N> outcome\` with: tasks done, evidence files, blockers, next-batch inputs).
 2. **Capture handoff facts** — the minimum information the next agent needs:
    - Stage and run id (from \`.cclaw/state/flow-state.json\`)
    - List of completed task IDs from the plan
    - Open blockers / failing gates by name
-   - File paths the next wave will touch (no full diffs)
+   - File paths the next batch will touch (no full diffs)
 3. **Decide: continue or rotate**
-   - **Rotate** (start a new agent session) when: prior wave consumed > ~50% of the context budget, the prior wave required deep investigation that the next wave does not need, or you are about to cross a stage boundary.
-   - **Continue** when: next wave is a tiny follow-up (≤ 1 task) and the prior context is directly relevant.
+   - **Rotate** (start a new agent session) when: prior batch consumed > ~50% of the context budget, the prior batch required deep investigation that the next batch does not need, or you are about to cross a stage boundary.
+   - **Continue** when: next batch is a tiny follow-up (≤ 1 task) and the prior context is directly relevant.
 4. **Resume** in the new session via \`/cc-next\` — the session-start hook will restore flow state, checkpoint, and digest automatically.
 
-This is the same intuition as Compound Engineering's "fresh context per iteration": every wave starts with a clean, intentionally-loaded context, not a degraded carry-over.
+This is the same intuition as Compound Engineering's "fresh context per iteration": every batch starts with a clean, intentionally-loaded context, not a degraded carry-over.
 
 ### Handoff template (paste into next session)
 
 \`\`\`markdown
-## Wave <N> handoff
+## Batch <N> handoff
 - Stage: <stage>
 - Run: <runId>
 - Completed task IDs: <list>
 - Blockers: <list or none>
-- Files next wave will touch: <list>
+- Files next batch will touch: <list>
 - Verification command(s) used: <list>
 \`\`\`
 
@@ -542,7 +542,7 @@ This is the same intuition as Compound Engineering's "fresh context per iteratio
 - Marking tasks done without command evidence.
 - Reordering critical dependencies for speed.
 - Continuing after a gate failure hoping later tasks fix it.
-- Carrying a saturated context across wave boundaries because "it has all the history" — saturated context is a liability, not an asset.
+- Carrying a saturated context across batch boundaries because "it has all the history" — saturated context is a liability, not an asset.
 `;
 }
 export function contextEngineeringSkill() {
@@ -1338,7 +1338,7 @@ For each lens, write either a knowledge entry **or** the explicit string
 
 ### 2. What slowed us down?
 
-- Repeated context loss between waves → \`[compound]\` accelerator.
+- Repeated context loss between batches → \`[compound]\` accelerator.
 - Re-derivation of a fact already in upstream artifacts → \`[pattern]\` "re-read X first".
 - Tooling friction (slow test loop, flaky CI) → \`[compound]\` follow-up.
 

package/dist/doctor.js

@@ -283,8 +283,8 @@ export async function doctorChecks(projectRoot, options = {}) {
             const skillContent = await fs.readFile(skillPath, "utf8");
             const lineCount = skillContent.split("\n").length;
             const MIN_SKILL_LINES = 110;
-            // Soft max tightened in wave 3 from 650 → 500 after externalising the
-            // TDD wave-execution walkthrough and collapsing the duplicate "what
+            // Soft max tightened from 650 → 500 after externalising the TDD
+            // batch-execution walkthrough and collapsing the duplicate "what
             // goes wrong" lists. Stage skills beyond 500 lines drift into unread
             // bloat; long-form content belongs under `.cclaw/references/` instead.
             const MAX_SKILL_LINES = 500;

package/dist/eval/baseline.js

@@ -1,5 +1,5 @@
 /**
- * Baseline I/O + regression comparison (Wave 7.1).
+ * Baseline I/O + regression comparison for the eval subsystem.
  *
  * Layout on disk (committed):
  *

package/dist/eval/corpus.d.ts

@@ -14,6 +14,17 @@ export declare function fixturePathFor(projectRoot: string, caseEntry: EvalCase)
 /**
  * Read the fixture artifact text for a case. Returns `undefined` if the case
  * has no fixture reference. Throws a descriptive error if the path exists in
- * the case but not on disk — Wave 7.1 fixtures ship alongside cases.
+ * the case but not on disk — structural fixtures ship alongside cases.
  */
 export declare function readFixtureArtifact(projectRoot: string, caseEntry: EvalCase): Promise<string | undefined>;
+/**
+ * Resolve an entry from `extraFixtures` to an absolute filesystem path,
+ * relative to the case's stage directory (same convention as `fixture`).
+ */
+export declare function extraFixturePath(projectRoot: string, caseEntry: EvalCase, label: string): string | undefined;
+/**
+ * Read every declared extra fixture for a case into a `{ label → text }`
+ * map. Missing files throw so authoring mistakes surface immediately rather
+ * than being silently skipped by cross-artifact verifiers.
+ */
+export declare function readExtraFixtures(projectRoot: string, caseEntry: EvalCase): Promise<Record<string, string>>;

package/dist/eval/corpus.js

@@ -58,6 +58,128 @@ function parseStructural(filePath, raw) {
         structural.maxChars = maxChars;
     return structural;
 }
+function parseRegexRule(filePath, context, value) {
+    if (typeof value === "string") {
+        return { pattern: value };
+    }
+    if (!isRecord(value)) {
+        throw corpusError(filePath, `"${context}" entries must be either a string or a mapping with "pattern"`);
+    }
+    const pattern = value.pattern;
+    if (typeof pattern !== "string" || pattern.length === 0) {
+        throw corpusError(filePath, `"${context}" mapping entry must include a non-empty "pattern" string`);
+    }
+    const flags = value.flags;
+    if (flags !== undefined && typeof flags !== "string") {
+        throw corpusError(filePath, `"${context}" flags must be a string`);
+    }
+    const description = value.description;
+    if (description !== undefined && typeof description !== "string") {
+        throw corpusError(filePath, `"${context}" description must be a string`);
+    }
+    const rule = { pattern };
+    if (flags !== undefined)
+        rule.flags = flags;
+    if (description !== undefined)
+        rule.description = description;
+    return rule;
+}
+function parseRegexRules(filePath, context, value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw corpusError(filePath, `"${context}" must be an array`);
+    }
+    return value.map((entry, index) => parseRegexRule(filePath, `${context}[${index}]`, entry));
+}
+function parseOccurrenceBounds(filePath, context, value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        throw corpusError(filePath, `"${context}" must be a mapping of phrase → integer`);
+    }
+    const out = {};
+    for (const [phrase, count] of Object.entries(value)) {
+        if (typeof count !== "number" || !Number.isFinite(count) || !Number.isInteger(count) || count < 0) {
+            throw corpusError(filePath, `"${context}.${phrase}" must be a non-negative integer`);
+        }
+        out[phrase] = count;
+    }
+    return out;
+}
+function parseRules(filePath, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isRecord(raw)) {
+        throw corpusError(filePath, `"expected.rules" must be a mapping`);
+    }
+    const mustContain = readStringArray(filePath, "expected.rules.must_contain", raw.must_contain ?? raw.mustContain);
+    const mustNotContain = readStringArray(filePath, "expected.rules.must_not_contain", raw.must_not_contain ?? raw.mustNotContain);
+    const regexRequired = parseRegexRules(filePath, "expected.rules.regex_required", raw.regex_required ?? raw.regexRequired);
+    const regexForbidden = parseRegexRules(filePath, "expected.rules.regex_forbidden", raw.regex_forbidden ?? raw.regexForbidden);
+    const minOccurrences = parseOccurrenceBounds(filePath, "expected.rules.min_occurrences", raw.min_occurrences ?? raw.minOccurrences);
+    const maxOccurrences = parseOccurrenceBounds(filePath, "expected.rules.max_occurrences", raw.max_occurrences ?? raw.maxOccurrences);
+    const uniqueBulletsInSection = readStringArray(filePath, "expected.rules.unique_bullets_in_section", raw.unique_bullets_in_section ?? raw.uniqueBulletsInSection);
+    const rules = {};
+    if (mustContain)
+        rules.mustContain = mustContain;
+    if (mustNotContain)
+        rules.mustNotContain = mustNotContain;
+    if (regexRequired)
+        rules.regexRequired = regexRequired;
+    if (regexForbidden)
+        rules.regexForbidden = regexForbidden;
+    if (minOccurrences)
+        rules.minOccurrences = minOccurrences;
+    if (maxOccurrences)
+        rules.maxOccurrences = maxOccurrences;
+    if (uniqueBulletsInSection)
+        rules.uniqueBulletsInSection = uniqueBulletsInSection;
+    return Object.keys(rules).length === 0 ? undefined : rules;
+}
+function parseTraceability(filePath, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isRecord(raw)) {
+        throw corpusError(filePath, `"expected.traceability" must be a mapping`);
+    }
+    const idPattern = raw.id_pattern ?? raw.idPattern;
+    if (typeof idPattern !== "string" || idPattern.length === 0) {
+        throw corpusError(filePath, `"expected.traceability.id_pattern" must be a non-empty regex source`);
+    }
+    const idFlags = raw.id_flags ?? raw.idFlags;
+    if (idFlags !== undefined && typeof idFlags !== "string") {
+        throw corpusError(filePath, `"expected.traceability.id_flags" must be a string`);
+    }
+    const source = raw.source;
+    if (typeof source !== "string" || source.length === 0) {
+        throw corpusError(filePath, `"expected.traceability.source" must be "self" or an extra_fixtures label`);
+    }
+    const requireInRaw = raw.require_in ?? raw.requireIn;
+    const requireIn = readStringArray(filePath, "expected.traceability.require_in", requireInRaw);
+    if (!requireIn || requireIn.length === 0) {
+        throw corpusError(filePath, `"expected.traceability.require_in" must be a non-empty array`);
+    }
+    const out = { idPattern, source, requireIn };
+    if (idFlags !== undefined)
+        out.idFlags = idFlags;
+    return out;
+}
+function parseExtraFixtures(filePath, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isRecord(raw)) {
+        throw corpusError(filePath, `"extra_fixtures" must be a mapping of label → path`);
+    }
+    const out = {};
+    for (const [label, value] of Object.entries(raw)) {
+        if (typeof value !== "string" || value.length === 0) {
+            throw corpusError(filePath, `"extra_fixtures.${label}" must be a non-empty path string`);
+        }
+        out[label] = value;
+    }
+    return Object.keys(out).length === 0 ? undefined : out;
+}
 function parseExpected(filePath, raw) {
     if (raw === undefined)
         return undefined;
@@ -68,12 +190,12 @@ function parseExpected(filePath, raw) {
     const structural = parseStructural(filePath, raw.structural);
     if (structural)
         shape.structural = structural;
-    if (raw.rules !== undefined) {
-        if (!isRecord(raw.rules)) {
-            throw corpusError(filePath, `"expected.rules" must be a mapping`);
-        }
-        shape.rules = raw.rules;
-    }
+    const rules = parseRules(filePath, raw.rules);
+    if (rules)
+        shape.rules = rules;
+    const traceability = parseTraceability(filePath, raw.traceability);
+    if (traceability)
+        shape.traceability = traceability;
     if (raw.judge !== undefined) {
         if (!isRecord(raw.judge)) {
             throw corpusError(filePath, `"expected.judge" must be a mapping`);
@@ -101,13 +223,15 @@ function validateCase(filePath, raw) {
     const contextFiles = readStringArray(filePath, "context_files", raw.context_files ?? raw.contextFiles);
     const expected = parseExpected(filePath, raw.expected);
     const fixture = typeof raw.fixture === "string" ? raw.fixture : undefined;
+    const extraFixtures = parseExtraFixtures(filePath, raw.extra_fixtures ?? raw.extraFixtures);
     return {
         id: id.trim(),
         stage: stageRaw,
         inputPrompt: inputPrompt.trim(),
         contextFiles,
         expected,
-        fixture
+        fixture,
+        extraFixtures
     };
 }
 /**
@@ -162,7 +286,7 @@ export function fixturePathFor(projectRoot, caseEntry) {
 /**
  * Read the fixture artifact text for a case. Returns `undefined` if the case
  * has no fixture reference. Throws a descriptive error if the path exists in
- * the case but not on disk — Wave 7.1 fixtures ship alongside cases.
+ * the case but not on disk — structural fixtures ship alongside cases.
  */
 export async function readFixtureArtifact(projectRoot, caseEntry) {
     const fixturePath = fixturePathFor(projectRoot, caseEntry);
@@ -173,3 +297,34 @@ export async function readFixtureArtifact(projectRoot, caseEntry) {
     }
     return fs.readFile(fixturePath, "utf8");
 }
+/**
+ * Resolve an entry from `extraFixtures` to an absolute filesystem path,
+ * relative to the case's stage directory (same convention as `fixture`).
+ */
+export function extraFixturePath(projectRoot, caseEntry, label) {
+    const value = caseEntry.extraFixtures?.[label];
+    if (!value)
+        return undefined;
+    return path.resolve(projectRoot, EVALS_ROOT, "corpus", caseEntry.stage, value);
+}
+/**
+ * Read every declared extra fixture for a case into a `{ label → text }`
+ * map. Missing files throw so authoring mistakes surface immediately rather
+ * than being silently skipped by cross-artifact verifiers.
+ */
+export async function readExtraFixtures(projectRoot, caseEntry) {
+    const out = {};
+    if (!caseEntry.extraFixtures)
+        return out;
+    for (const label of Object.keys(caseEntry.extraFixtures)) {
+        const filePath = extraFixturePath(projectRoot, caseEntry, label);
+        if (!filePath)
+            continue;
+        if (!(await exists(filePath))) {
+            throw new Error(`Extra fixture missing for ${caseEntry.stage}/${caseEntry.id} ` +
+                `(label="${label}"): ${filePath}`);
+        }
+        out[label] = await fs.readFile(filePath, "utf8");
+    }
+    return out;
+}

package/dist/eval/llm-client.d.ts

@@ -1,17 +1,17 @@
 /**
  * LLM client skeleton for the cclaw eval subsystem.
  *
- * Wave 7.0 declares the shape of the client without pulling in the `openai`
- * runtime dependency. The real implementation is wired in Wave 7.3 when
+ * This module declares the shape of the client without pulling in the
+ * `openai` runtime dependency. The real implementation lands when
  * single-shot (Tier A) evals and LLM judging come online. Keeping this stub
- * separate means users of Waves 7.0–7.2 (structural + rule-based verifiers)
- * never install an extra dependency or receive network egress warnings.
+ * separate means users who only run structural + rule-based verifiers never
+ * install an extra dependency or receive network egress warnings.
  */
 import type { ResolvedEvalConfig } from "./types.js";
 /**
  * Minimal chat interface the rest of the eval code will depend on. It is
  * intentionally a subset of OpenAI's Chat Completions surface so that the
- * Wave 7.3 implementation is a thin adapter around `OpenAI.chat.completions.create`.
+ * real implementation is a thin adapter around `OpenAI.chat.completions.create`.
  */
 export interface ChatMessage {
     role: "system" | "user" | "assistant" | "tool";
@@ -26,8 +26,8 @@ export interface ChatRequest {
     temperature?: number;
     timeoutMs?: number;
     /**
-     * Tool/function-calling definitions in OpenAI wire format. Populated only by
-     * Wave 7.4 (Tier B). Ignored by the Wave 7.3 single-shot path.
+     * Tool/function-calling definitions in OpenAI wire format. Populated only
+     * by Tier B. Ignored by the Tier A single-shot path.
      */
     tools?: unknown[];
     toolChoice?: "auto" | "none";
@@ -52,11 +52,11 @@ export interface EvalLlmClient {
     chat(request: ChatRequest): Promise<ChatResponse>;
 }
 export declare class EvalLlmNotWiredError extends Error {
-    constructor(wave: string);
+    constructor();
 }
 /**
- * Factory stub. Throws with a clear message so accidental Wave 7.0 usage is
- * easy to diagnose. The Wave 7.3 implementation will replace this body with
+ * Factory stub. Throws with a clear message so accidental early usage is
+ * easy to diagnose. The real implementation will replace this body with
  * `new OpenAI({ apiKey, baseURL }) ... adapter`.
  */
 export declare function createEvalClient(_config: ResolvedEvalConfig): EvalLlmClient;

package/dist/eval/llm-client.js

@@ -1,19 +1,19 @@
 export class EvalLlmNotWiredError extends Error {
-    constructor(wave) {
-        super(`LLM client is not wired in Wave 7.0. It arrives in Wave ${wave}.\n` +
+    constructor() {
+        super(`LLM client is not wired yet.\n` +
             `Run \`cclaw eval --dry-run\` or \`cclaw eval --schema-only\` for offline evals.`);
         this.name = "EvalLlmNotWiredError";
     }
 }
 /**
- * Factory stub. Throws with a clear message so accidental Wave 7.0 usage is
- * easy to diagnose. The Wave 7.3 implementation will replace this body with
+ * Factory stub. Throws with a clear message so accidental early usage is
+ * easy to diagnose. The real implementation will replace this body with
  * `new OpenAI({ apiKey, baseURL }) ... adapter`.
  */
 export function createEvalClient(_config) {
     return {
         async chat() {
-            throw new EvalLlmNotWiredError("7.3");
+            throw new EvalLlmNotWiredError();
         }
     };
 }

package/dist/eval/report.js

@@ -62,7 +62,7 @@ export function formatMarkdownReport(report) {
     if (report.cases.length === 0) {
         lines.push(`## Cases`);
         lines.push(``);
-        lines.push(`No cases were executed. See \`docs/evals.md\` for the Wave rollout plan.`);
+        lines.push(`No cases were executed. See \`docs/evals.md\` for the rollout plan.`);
         lines.push(``);
         return `${lines.join("\n")}\n`;
     }

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). */
+    /** 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;
@@ -36,10 +36,10 @@ export interface DryRunSummary {
     notes: string[];
 }
 /**
- * Wave 7.1 runner. When `schemaOnly` is set (or no other verifier flags are
+ * 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
- * still arrive in Waves 7.3+; until then cases without `fixture` are marked
- * as skipped rather than failing.
+ * 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

@@ -2,9 +2,11 @@ import { randomUUID } from "node:crypto";
 import { CCLAW_VERSION } from "../constants.js";
 import { FLOW_STAGES } from "../types.js";
 import { compareAgainstBaselines, loadBaselinesByStage } from "./baseline.js";
-import { loadCorpus, readFixtureArtifact } from "./corpus.js";
+import { loadCorpus, readExtraFixtures, readFixtureArtifact } from "./corpus.js";
 import { loadEvalConfig } from "./config-loader.js";
+import { verifyRules } from "./verifiers/rules.js";
 import { verifyStructural } from "./verifiers/structural.js";
+import { verifyTraceability } from "./verifiers/traceability.js";
 function groupByStage(cases) {
     return cases.reduce((acc, item) => {
         acc[item.stage] = (acc[item.stage] ?? 0) + 1;
@@ -14,40 +16,72 @@ function groupByStage(cases) {
 function skeletonVerifierResult(message, details) {
     return {
         kind: "structural",
-        id: "wave-7-1-no-structural-expected",
+        id: "structural:no-expectations",
         ok: true,
         score: 1,
         message,
         ...(details !== undefined ? { details } : {})
     };
 }
-async function runCaseStructural(projectRoot, caseEntry, plannedTier) {
+/**
+ * --schema-only narrows to structural. --rules opens up rules + traceability
+ * on top of structural (traceability is a rule-family verifier even though
+ * it lives in its own module). Default (no flag) matches --schema-only for
+ * backwards compatibility with the Step 1 gate.
+ */
+function resolveRunFlags(options) {
+    const rulesRequested = options.rules === true;
+    const schemaOnly = options.schemaOnly === true;
+    return {
+        runStructural: true,
+        runRules: rulesRequested && !schemaOnly,
+        runTraceability: rulesRequested && !schemaOnly
+    };
+}
+async function loadArtifactOrRecord(projectRoot, caseEntry, verifierResults) {
+    try {
+        return 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 }
+        });
+        return undefined;
+    }
+}
+async function runCase(projectRoot, caseEntry, plannedTier, flags) {
     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) {
+    const expected = caseEntry.expected;
+    const hasStructural = !!expected?.structural && Object.keys(expected.structural).length > 0;
+    const hasRules = flags.runRules && !!expected?.rules && Object.keys(expected.rules).length > 0;
+    const hasTraceability = flags.runTraceability && !!expected?.traceability;
+    const needsArtifact = hasStructural || hasRules || hasTraceability;
+    let artifact;
+    if (needsArtifact) {
+        artifact = await loadArtifactOrRecord(projectRoot, caseEntry, verifierResults);
+        if (artifact === undefined && verifierResults.length === 0) {
             verifierResults.push({
                 kind: "structural",
-                id: "structural:fixture:missing",
+                id: "structural:fixture:absent",
                 ok: false,
                 score: 0,
-                message: err instanceof Error ? err.message : String(err),
-                details: { fixture: caseEntry.fixture }
+                message: "Expectations declared but no fixture path provided. Add `fixture: ./<id>/fixture.md`.",
+                details: { fixtureProvided: false }
             });
         }
-        if (artifact !== undefined) {
-            const results = verifyStructural(artifact, structuralExpected);
+    }
+    if (flags.runStructural) {
+        if (!hasStructural) {
+            verifierResults.push(skeletonVerifierResult("No structural expectations declared for this case; structural verifier skipped.", { skipped: true }));
+        }
+        else if (artifact !== undefined) {
+            const results = verifyStructural(artifact, expected.structural);
             if (results.length === 0) {
                 verifierResults.push(skeletonVerifierResult("Structural expectations parsed but produced zero checks.", { skipped: true }));
             }
@@ -55,18 +89,32 @@ async function runCaseStructural(projectRoot, caseEntry, plannedTier) {
                 verifierResults.push(...results);
             }
         }
-        else if (verifierResults.length === 0) {
+    }
+    if (hasRules && artifact !== undefined) {
+        const results = verifyRules(artifact, expected.rules);
+        verifierResults.push(...results);
+    }
+    if (hasTraceability && artifact !== undefined) {
+        try {
+            const extras = await readExtraFixtures(projectRoot, caseEntry);
+            const results = verifyTraceability(artifact, extras, expected.traceability);
+            verifierResults.push(...results);
+        }
+        catch (err) {
             verifierResults.push({
-                kind: "structural",
-                id: "structural:fixture:absent",
+                kind: "rules",
+                id: "traceability:fixture:missing",
                 ok: false,
                 score: 0,
-                message: "Structural expectations declared but no fixture path provided. Add `fixture: ./<id>/fixture.md`.",
-                details: { fixtureProvided: false }
+                message: err instanceof Error ? err.message : String(err),
+                details: { extraFixtures: Object.keys(caseEntry.extraFixtures ?? {}) }
             });
         }
     }
-    const allOk = verifierResults.every((r) => r.ok);
+    const nonSkippedResults = verifierResults.filter((r) => r.details?.skipped !== true);
+    const allOk = nonSkippedResults.length === 0
+        ? verifierResults.every((r) => r.ok)
+        : nonSkippedResults.every((r) => r.ok);
     return {
         caseId: caseEntry.id,
         stage: caseEntry.stage,
@@ -111,11 +159,11 @@ function stagesInResults(caseResults) {
     return FLOW_STAGES.filter((s) => set.has(s));
 }
 /**
- * Wave 7.1 runner. When `schemaOnly` is set (or no other verifier flags are
+ * 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
- * still arrive in Waves 7.3+; until then cases without `fixture` are marked
- * as skipped rather than failing.
+ * 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);
@@ -125,12 +173,10 @@ export async function runEval(options) {
     if (corpus.length === 0) {
         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.");
-    }
     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.");
     }
+    const flags = resolveRunFlags(options);
     if (options.dryRun === true) {
         const summary = {
             kind: "dry-run",
@@ -142,8 +188,8 @@ export async function runEval(options) {
             },
             plannedTier,
             verifiersAvailable: {
-                structural: true,
-                rules: false,
+                structural: flags.runStructural,
+                rules: flags.runRules,
                 judge: false,
                 workflow: false
             },
@@ -154,7 +200,7 @@ export async function runEval(options) {
     const now = new Date().toISOString();
     const caseResults = [];
     for (const item of corpus) {
-        caseResults.push(await runCaseStructural(options.projectRoot, item, plannedTier));
+        caseResults.push(await runCase(options.projectRoot, item, plannedTier, flags));
     }
     const stages = stagesInResults(caseResults);
     const baselines = await loadBaselinesByStage(options.projectRoot, stages);