@ncoderz/awa 1.0.0 → 1.1.0

package/dist/index.js

@@ -6,14 +6,1169 @@ import { Command } from "commander";
 // src/_generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@ncoderz/awa",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "author": "Richard Sewell <richard.sewell@ncoderz.com>",
   "license": "MIT",
   "description": "awa is an Agent Workflow for AIs. It is also a CLI tool to powerfully manage agent workflow files using templates."
 };
 
-// src/commands/diff.ts
-import { intro, outro } from "@clack/prompts";
+// src/core/check/code-spec-checker.ts
+function checkCodeAgainstSpec(markers, specs, config) {
+  const findings = [];
+  const idRegex = new RegExp(`^${config.idPattern}$`);
+  for (const marker of markers.markers) {
+    if (marker.type === "component") {
+      continue;
+    }
+    if (!idRegex.test(marker.id)) {
+      findings.push({
+        severity: "error",
+        code: "invalid-id-format",
+        message: `Marker ID '${marker.id}' does not match expected pattern: ${config.idPattern}`,
+        filePath: marker.filePath,
+        line: marker.line,
+        id: marker.id
+      });
+    }
+  }
+  for (const marker of markers.markers) {
+    if (marker.type === "component") {
+      if (!specs.componentNames.has(marker.id)) {
+        findings.push({
+          severity: "error",
+          code: "orphaned-marker",
+          message: `Component marker '${marker.id}' not found in any spec file`,
+          filePath: marker.filePath,
+          line: marker.line,
+          id: marker.id
+        });
+      }
+    } else {
+      if (!specs.allIds.has(marker.id)) {
+        findings.push({
+          severity: "error",
+          code: "orphaned-marker",
+          message: `Marker '${marker.id}' not found in any spec file`,
+          filePath: marker.filePath,
+          line: marker.line,
+          id: marker.id
+        });
+      }
+    }
+  }
+  const testedIds = new Set(markers.markers.filter((m) => m.type === "test").map((m) => m.id));
+  for (const acId of specs.acIds) {
+    if (!testedIds.has(acId)) {
+      const loc = specs.idLocations.get(acId);
+      const specFile = loc ? void 0 : specs.specFiles.find((sf) => sf.acIds.includes(acId));
+      findings.push({
+        severity: "warning",
+        code: "uncovered-ac",
+        message: `Acceptance criterion '${acId}' has no @awa-test reference`,
+        filePath: loc?.filePath ?? specFile?.filePath,
+        line: loc?.line,
+        id: acId
+      });
+    }
+  }
+  return { findings };
+}
+
+// src/core/check/marker-scanner.ts
+import { readFile } from "fs/promises";
+
+// src/core/check/glob.ts
+import { glob } from "fs/promises";
+function matchSimpleGlob(path, pattern) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*");
+  return new RegExp(`(^|/)${regex}($|/)`).test(path);
+}
+async function collectFiles(globs, ignore) {
+  const files = [];
+  const dirPrefixes = ignore.filter((ig) => ig.endsWith("/**")).map((ig) => ig.slice(0, -3));
+  for (const pattern of globs) {
+    for await (const filePath of glob(pattern, {
+      exclude: (p) => dirPrefixes.includes(p) || ignore.some((ig) => matchSimpleGlob(p, ig))
+    })) {
+      if (!ignore.some((ig) => matchSimpleGlob(filePath, ig))) {
+        files.push(filePath);
+      }
+    }
+  }
+  return [...new Set(files)];
+}
+
+// src/core/check/marker-scanner.ts
+var MARKER_TYPE_MAP = {
+  "@awa-impl": "impl",
+  "@awa-test": "test",
+  "@awa-component": "component"
+};
+var IGNORE_FILE_RE = /@awa-ignore-file\b/;
+var IGNORE_NEXT_LINE_RE = /@awa-ignore-next-line\b/;
+var IGNORE_LINE_RE = /@awa-ignore\b/;
+var IGNORE_START_RE = /@awa-ignore-start\b/;
+var IGNORE_END_RE = /@awa-ignore-end\b/;
+async function scanMarkers(config) {
+  const files = await collectCodeFiles(config.codeGlobs, config.ignore);
+  const markers = [];
+  const findings = [];
+  for (const filePath of files) {
+    if (config.ignoreMarkers.some((ig) => matchSimpleGlob(filePath, ig))) {
+      continue;
+    }
+    const result = await scanFile(filePath, config.markers);
+    markers.push(...result.markers);
+    findings.push(...result.findings);
+  }
+  return { markers, findings };
+}
+function buildMarkerRegex(markerNames) {
+  const escaped = markerNames.map((m) => m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`(${escaped.join("|")}):\\s*(.+)`, "g");
+}
+var ID_TOKEN_RE = /^([A-Z][A-Z0-9]*(?:[-_][A-Za-z0-9]+)*(?:\.\d+)?)/;
+async function scanFile(filePath, markerNames) {
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return { markers: [], findings: [] };
+  }
+  if (IGNORE_FILE_RE.test(content)) {
+    return { markers: [], findings: [] };
+  }
+  const regex = buildMarkerRegex(markerNames);
+  const lines = content.split("\n");
+  const markers = [];
+  const findings = [];
+  let ignoreNextLine = false;
+  let ignoreBlock = false;
+  for (const [i, line] of lines.entries()) {
+    if (IGNORE_START_RE.test(line)) {
+      ignoreBlock = true;
+      continue;
+    }
+    if (IGNORE_END_RE.test(line)) {
+      ignoreBlock = false;
+      continue;
+    }
+    if (ignoreBlock) {
+      continue;
+    }
+    if (ignoreNextLine) {
+      ignoreNextLine = false;
+      continue;
+    }
+    if (IGNORE_NEXT_LINE_RE.test(line)) {
+      ignoreNextLine = true;
+      continue;
+    }
+    if (IGNORE_LINE_RE.test(line)) {
+      continue;
+    }
+    regex.lastIndex = 0;
+    let match = regex.exec(line);
+    while (match !== null) {
+      const markerName = match[1] ?? "";
+      const idsRaw = match[2] ?? "";
+      const type = resolveMarkerType(markerName, markerNames);
+      const ids = idsRaw.split(",").map((id) => id.trim()).filter(Boolean);
+      for (const id of ids) {
+        const tokenMatch = ID_TOKEN_RE.exec(id);
+        const cleanId = tokenMatch?.[1]?.trim() ?? "";
+        if (cleanId && tokenMatch) {
+          const remainder = id.slice(tokenMatch[0].length).trim();
+          if (remainder) {
+            findings.push({
+              severity: "error",
+              code: "marker-trailing-text",
+              message: `Marker has trailing text after ID '${cleanId}': '${remainder}' \u2014 use comma-separated IDs only`,
+              filePath,
+              line: i + 1,
+              id: cleanId
+            });
+          }
+          markers.push({ type, id: cleanId, filePath, line: i + 1 });
+        }
+      }
+      match = regex.exec(line);
+    }
+  }
+  return { markers, findings };
+}
+function resolveMarkerType(markerName, configuredMarkers) {
+  const mapped = MARKER_TYPE_MAP[markerName];
+  if (mapped) return mapped;
+  const idx = configuredMarkers.indexOf(markerName);
+  if (idx === 1) return "test";
+  if (idx === 2) return "component";
+  return "impl";
+}
+async function collectCodeFiles(codeGlobs, ignore) {
+  return collectFiles(codeGlobs, ignore);
+}
+
+// src/core/check/reporter.ts
+import chalk from "chalk";
+function report(findings, format) {
+  if (format === "json") {
+    reportJson(findings);
+  } else {
+    reportText(findings);
+  }
+}
+function reportJson(findings) {
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const output = {
+    valid: errors.length === 0,
+    errors: errors.length,
+    warnings: warnings.length,
+    findings: findings.map((f) => ({
+      severity: f.severity,
+      code: f.code,
+      message: f.message,
+      ...f.filePath ? { filePath: f.filePath } : {},
+      ...f.line ? { line: f.line } : {},
+      ...f.id ? { id: f.id } : {},
+      ...f.ruleSource ? { ruleSource: f.ruleSource } : {},
+      ...f.rule ? { rule: f.rule } : {}
+    }))
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+function reportText(findings) {
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  if (errors.length > 0) {
+    console.log(chalk.red(`
+${errors.length} error(s):
+`));
+    for (const f of errors) {
+      const location = formatLocation(f.filePath, f.line);
+      console.log(chalk.red("  \u2716"), f.message, location ? chalk.dim(location) : "");
+      printRuleContext(f);
+    }
+  }
+  if (warnings.length > 0) {
+    console.log(chalk.yellow(`
+${warnings.length} warning(s):
+`));
+    for (const f of warnings) {
+      const location = formatLocation(f.filePath, f.line);
+      console.log(chalk.yellow("  \u26A0"), f.message, location ? chalk.dim(location) : "");
+      printRuleContext(f);
+    }
+  }
+  if (errors.length === 0 && warnings.length === 0) {
+    console.log(chalk.green("\n\u2714 Validation passed \u2014 no issues found"));
+  } else {
+    console.log("");
+    const parts = [];
+    if (errors.length > 0) parts.push(chalk.red(`${errors.length} error(s)`));
+    if (warnings.length > 0) parts.push(chalk.yellow(`${warnings.length} warning(s)`));
+    console.log(`Summary: ${parts.join(", ")}`);
+  }
+}
+function formatLocation(filePath, line) {
+  if (!filePath) return "";
+  return line ? `(${filePath}:${line})` : `(${filePath})`;
+}
+function printRuleContext(f) {
+  if (!f.ruleSource && !f.rule) return;
+  const parts = [];
+  if (f.ruleSource) parts.push(f.ruleSource);
+  if (f.rule) parts.push(f.rule);
+  console.log(chalk.dim(`      rule: ${parts.join(" \u2014 ")}`));
+}
+
+// src/core/check/rule-loader.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+async function loadRules(schemaDir) {
+  const pattern = join(schemaDir, "*.schema.yaml");
+  const files = await collectFiles([pattern], []);
+  const results = [];
+  for (const filePath of files) {
+    const ruleSet = await loadRuleFile(filePath);
+    if (ruleSet) {
+      results.push(ruleSet);
+    }
+  }
+  return results;
+}
+function matchesTargetGlob(filePath, targetGlob) {
+  return matchSimpleGlob(filePath, targetGlob);
+}
+async function loadRuleFile(filePath) {
+  let content;
+  try {
+    content = await readFile2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const parsed = parseYaml(content);
+  if (!parsed || typeof parsed !== "object") {
+    throw new RuleValidationError(`Rule file is not a valid YAML object: ${filePath}`);
+  }
+  const raw = parsed;
+  const ruleFile = validateRuleFile(raw, filePath);
+  return {
+    ruleFile,
+    sourcePath: filePath,
+    targetGlob: ruleFile["target-files"]
+  };
+}
+function validateRuleFile(raw, filePath) {
+  if (typeof raw["target-files"] !== "string" || raw["target-files"].length === 0) {
+    throw new RuleValidationError(`Missing or empty 'target-files' in ${filePath}`);
+  }
+  let sections;
+  if (raw.sections !== void 0) {
+    if (!Array.isArray(raw.sections) || raw.sections.length === 0) {
+      throw new RuleValidationError(
+        `'sections' must be a non-empty array if present in ${filePath}`
+      );
+    }
+    sections = raw.sections.map(
+      (s, i) => validateSectionRule(s, `sections[${i}]`, filePath)
+    );
+  }
+  let sectionsProhibited;
+  if (raw["sections-prohibited"] !== void 0) {
+    if (!Array.isArray(raw["sections-prohibited"]) || !raw["sections-prohibited"].every((v) => typeof v === "string")) {
+      throw new RuleValidationError(`'sections-prohibited' must be a string array in ${filePath}`);
+    }
+    sectionsProhibited = raw["sections-prohibited"];
+  }
+  return {
+    "target-files": raw["target-files"],
+    ...typeof raw.description === "string" ? { description: raw.description } : {},
+    ...typeof raw["line-limit"] === "number" && raw["line-limit"] > 0 ? { "line-limit": raw["line-limit"] } : {},
+    sections: sections ?? [],
+    ...sectionsProhibited ? { "sections-prohibited": sectionsProhibited } : {},
+    ...typeof raw.example === "string" ? { example: raw.example } : {}
+  };
+}
+function validateSectionRule(raw, path, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new RuleValidationError(`${path} must be an object in ${filePath}`);
+  }
+  const section = raw;
+  if (typeof section.heading !== "string" || section.heading.length === 0) {
+    throw new RuleValidationError(`${path}.heading must be a non-empty string in ${filePath}`);
+  }
+  if (typeof section.level !== "number" || section.level < 1 || section.level > 6) {
+    throw new RuleValidationError(`${path}.level must be 1-6 in ${filePath}`);
+  }
+  validatePattern(section.heading, `${path}.heading`, filePath);
+  let contains;
+  if (section.contains !== void 0) {
+    if (!Array.isArray(section.contains)) {
+      throw new RuleValidationError(`${path}.contains must be an array in ${filePath}`);
+    }
+    contains = section.contains.map(
+      (c, i) => validateContainsRule(c, `${path}.contains[${i}]`, filePath)
+    );
+  }
+  let children;
+  if (section.children !== void 0) {
+    if (!Array.isArray(section.children)) {
+      throw new RuleValidationError(`${path}.children must be an array in ${filePath}`);
+    }
+    children = section.children.map(
+      (c, i) => validateSectionRule(c, `${path}.children[${i}]`, filePath)
+    );
+  }
+  return {
+    heading: section.heading,
+    level: section.level,
+    ...typeof section.required === "boolean" ? { required: section.required } : {},
+    ...typeof section.repeatable === "boolean" ? { repeatable: section.repeatable } : {},
+    ...typeof section.description === "string" ? { description: section.description } : {},
+    ...contains ? { contains } : {},
+    ...children ? { children } : {}
+  };
+}
+function validateContainsRule(raw, path, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new RuleValidationError(`${path} must be an object in ${filePath}`);
+  }
+  const rule = raw;
+  const when = rule.when !== void 0 ? validateWhenCondition(rule.when, `${path}.when`, filePath) : void 0;
+  if (typeof rule.pattern === "string") {
+    validatePattern(rule.pattern, `${path}.pattern`, filePath);
+    return {
+      pattern: rule.pattern,
+      ...typeof rule.label === "string" ? { label: rule.label } : {},
+      ...typeof rule.description === "string" ? { description: rule.description } : {},
+      ...typeof rule.required === "boolean" ? { required: rule.required } : {},
+      ...typeof rule.prohibited === "boolean" ? { prohibited: rule.prohibited } : {},
+      ...when ? { when } : {}
+    };
+  }
+  if (rule.list && typeof rule.list === "object") {
+    const list = rule.list;
+    if (typeof list.pattern !== "string") {
+      throw new RuleValidationError(`${path}.list.pattern must be a string in ${filePath}`);
+    }
+    validatePattern(list.pattern, `${path}.list.pattern`, filePath);
+    return {
+      list: {
+        pattern: list.pattern,
+        ...typeof list.min === "number" ? { min: list.min } : {},
+        ...typeof list.label === "string" ? { label: list.label } : {}
+      },
+      ...typeof rule.description === "string" ? { description: rule.description } : {},
+      ...when ? { when } : {}
+    };
+  }
+  if (rule.table && typeof rule.table === "object") {
+    const table = rule.table;
+    if (!Array.isArray(table.columns) || !table.columns.every((c) => typeof c === "string")) {
+      throw new RuleValidationError(`${path}.table.columns must be a string array in ${filePath}`);
+    }
+    return {
+      table: {
+        ...typeof table.heading === "string" ? { heading: table.heading } : {},
+        columns: table.columns,
+        ...typeof table["min-rows"] === "number" ? { "min-rows": table["min-rows"] } : {}
+      },
+      ...typeof rule.description === "string" ? { description: rule.description } : {},
+      ...when ? { when } : {}
+    };
+  }
+  if (rule["code-block"] === true) {
+    return {
+      "code-block": true,
+      ...typeof rule.label === "string" ? { label: rule.label } : {},
+      ...typeof rule.description === "string" ? { description: rule.description } : {},
+      ...when ? { when } : {}
+    };
+  }
+  if (typeof rule["heading-or-text"] === "string") {
+    return {
+      "heading-or-text": rule["heading-or-text"],
+      ...typeof rule.required === "boolean" ? { required: rule.required } : {},
+      ...typeof rule.description === "string" ? { description: rule.description } : {},
+      ...when ? { when } : {}
+    };
+  }
+  throw new RuleValidationError(`${path} has no recognized rule type in ${filePath}`);
+}
+function validateWhenCondition(raw, path, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new RuleValidationError(`${path} must be an object in ${filePath}`);
+  }
+  const condition = raw;
+  const result = {};
+  if (typeof condition["heading-matches"] === "string") {
+    validatePattern(condition["heading-matches"], `${path}.heading-matches`, filePath);
+    result["heading-matches"] = condition["heading-matches"];
+  }
+  if (typeof condition["heading-not-matches"] === "string") {
+    validatePattern(condition["heading-not-matches"], `${path}.heading-not-matches`, filePath);
+    result["heading-not-matches"] = condition["heading-not-matches"];
+  }
+  if (!result["heading-matches"] && !result["heading-not-matches"]) {
+    throw new RuleValidationError(
+      `${path} must have 'heading-matches' or 'heading-not-matches' in ${filePath}`
+    );
+  }
+  return result;
+}
+function validatePattern(pattern, path, filePath) {
+  if (/[.+*?^${}()|[\]\\]/.test(pattern)) {
+    try {
+      new RegExp(pattern);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new RuleValidationError(`Invalid regex in ${path}: ${msg} (${filePath})`);
+    }
+  }
+}
+var RuleValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RuleValidationError";
+  }
+};
+
+// src/core/check/schema-checker.ts
+import { readFile as readFile3 } from "fs/promises";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function formatSectionRule(rule) {
+  const parts = [`section: heading="${rule.heading}" level=${rule.level}`];
+  if (rule.required) parts.push("required");
+  if (rule.repeatable) parts.push("repeatable");
+  return parts.join(" ");
+}
+function formatContainsRule(rule) {
+  if ("pattern" in rule && typeof rule.pattern === "string") {
+    const r = rule;
+    if (r.prohibited) return `contains: prohibited pattern="${r.pattern}"`;
+    return `contains: pattern="${r.pattern}"${r.required === false ? "" : " required"}`;
+  }
+  if ("list" in rule) {
+    const r = rule;
+    return `contains: list pattern="${r.list.pattern}"${r.list.min !== void 0 ? ` min=${r.list.min}` : ""}`;
+  }
+  if ("table" in rule) {
+    const r = rule;
+    return `contains: table columns=[${r.table.columns.join(", ")}]${r.table["min-rows"] !== void 0 ? ` min-rows=${r.table["min-rows"]}` : ""}`;
+  }
+  if ("code-block" in rule) {
+    return "contains: code-block";
+  }
+  if ("heading-or-text" in rule) {
+    const r = rule;
+    return `contains: heading-or-text="${r["heading-or-text"]}"`;
+  }
+  return "contains: (unknown rule)";
+}
+function formatLineLimitRule(limit) {
+  return `line-limit: ${limit}`;
+}
+function formatProhibitedRule(pattern) {
+  return `sections-prohibited: "${pattern}"`;
+}
+async function checkSchemasAsync(specFiles, ruleSets) {
+  const findings = [];
+  const parser = unified().use(remarkParse).use(remarkGfm);
+  for (const spec of specFiles) {
+    const matchingRules = ruleSets.filter((rs) => matchesTargetGlob(spec.filePath, rs.targetGlob));
+    if (matchingRules.length === 0) continue;
+    let content;
+    try {
+      content = await readFile3(spec.filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const tree = parser.parse(content);
+    const sectionTree = buildSectionTree(tree);
+    const allSections = flattenSections(sectionTree);
+    for (const ruleSet of matchingRules) {
+      const ruleSource = ruleSet.sourcePath;
+      if (ruleSet.ruleFile["line-limit"] !== void 0) {
+        const lineCount = content.split("\n").length;
+        if (lineCount > ruleSet.ruleFile["line-limit"]) {
+          findings.push({
+            severity: "warning",
+            code: "schema-line-limit",
+            message: `File has ${lineCount} lines, exceeds limit of ${ruleSet.ruleFile["line-limit"]}`,
+            filePath: spec.filePath,
+            ruleSource,
+            rule: formatLineLimitRule(ruleSet.ruleFile["line-limit"])
+          });
+        }
+      }
+      findings.push(
+        ...checkRulesAgainstSections(
+          allSections,
+          ruleSet.ruleFile.sections,
+          spec.filePath,
+          ruleSource
+        )
+      );
+      if (ruleSet.ruleFile["sections-prohibited"]) {
+        findings.push(
+          ...checkProhibited(
+            content,
+            ruleSet.ruleFile["sections-prohibited"],
+            spec.filePath,
+            ruleSource
+          )
+        );
+      }
+    }
+  }
+  return { findings };
+}
+function buildSectionTree(tree) {
+  return buildSectionsFromNodes(tree.children, 0, 0).sections;
+}
+function buildSectionsFromNodes(nodes, start, parentLevel) {
+  const sections = [];
+  let i = start;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    if (!node) break;
+    if (node.type === "heading") {
+      const h = node;
+      if (parentLevel > 0 && h.depth <= parentLevel) break;
+      const headingText = extractText(h.children);
+      const contentNodes = [];
+      i++;
+      while (i < nodes.length) {
+        const next = nodes[i];
+        if (!next || next.type === "heading") break;
+        contentNodes.push(next);
+        i++;
+      }
+      const childResult = buildSectionsFromNodes(nodes, i, h.depth);
+      i = childResult.nextIndex;
+      sections.push({
+        heading: h,
+        headingText,
+        level: h.depth,
+        children: childResult.sections,
+        contentNodes
+      });
+    } else {
+      i++;
+    }
+  }
+  return { sections, nextIndex: i };
+}
+function flattenSections(sections) {
+  const result = [];
+  for (const s of sections) {
+    result.push(s);
+    result.push(...flattenSections(s.children));
+  }
+  return result;
+}
+function extractText(children) {
+  return children.map((c) => {
+    if ("value" in c) return c.value;
+    if ("children" in c) return extractText(c.children);
+    return "";
+  }).join("");
+}
+function checkRulesAgainstSections(allSections, rules, filePath, ruleSource) {
+  const findings = [];
+  for (const rule of rules) {
+    const matches = findMatchingSections(allSections, rule);
+    if (matches.length === 0 && rule.required) {
+      findings.push({
+        severity: "error",
+        code: "schema-missing-section",
+        message: `Missing required section: '${rule.heading}' (level ${rule.level})`,
+        filePath,
+        ruleSource,
+        rule: formatSectionRule(rule)
+      });
+      continue;
+    }
+    for (const match of matches) {
+      if (match.level !== rule.level) {
+        findings.push({
+          severity: "warning",
+          code: "schema-wrong-level",
+          message: `Section '${match.headingText}' is level ${match.level}, expected ${rule.level}`,
+          filePath,
+          line: match.heading.position?.start.line,
+          ruleSource,
+          rule: formatSectionRule(rule)
+        });
+      }
+      if (rule.contains) {
+        for (const cr of rule.contains) {
+          findings.push(...checkContainsRule(match, cr, filePath, ruleSource));
+        }
+      }
+      if (rule.children) {
+        const childFlat = flattenSections(match.children);
+        findings.push(...checkRulesAgainstSections(childFlat, rule.children, filePath, ruleSource));
+      }
+    }
+  }
+  return findings;
+}
+function findMatchingSections(allSections, rule) {
+  const regex = createHeadingRegex(rule.heading);
+  const matches = allSections.filter((s) => s.level === rule.level && regex.test(s.headingText));
+  if (!rule.repeatable && matches.length > 1) {
+    return [matches[0]];
+  }
+  return matches;
+}
+function createHeadingRegex(pattern) {
+  if (/[.+*?^${}()|[\]\\]/.test(pattern)) {
+    try {
+      return new RegExp(`^${pattern}$`);
+    } catch {
+      return new RegExp(`^${escapeRegex(pattern)}$`);
+    }
+  }
+  return new RegExp(`^${escapeRegex(pattern)}$`, "i");
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function checkContainsRule(section, rule, filePath, ruleSource) {
+  const when = "when" in rule ? rule.when : void 0;
+  if (when && !evaluateWhenCondition(when, section.headingText)) {
+    return [];
+  }
+  const formattedRule = formatContainsRule(rule);
+  if ("pattern" in rule && typeof rule.pattern === "string") {
+    return checkPatternContains(
+      section,
+      rule,
+      filePath,
+      ruleSource,
+      formattedRule
+    );
+  }
+  if ("list" in rule) {
+    return checkListContains(
+      section,
+      rule,
+      filePath,
+      ruleSource,
+      formattedRule
+    );
+  }
+  if ("table" in rule) {
+    return checkTableContains(
+      section,
+      rule,
+      filePath,
+      ruleSource,
+      formattedRule
+    );
+  }
+  if ("code-block" in rule) {
+    return checkCodeBlockContains(
+      section,
+      rule,
+      filePath,
+      ruleSource,
+      formattedRule
+    );
+  }
+  if ("heading-or-text" in rule) {
+    return checkHeadingOrText(
+      section,
+      rule,
+      filePath,
+      ruleSource,
+      formattedRule
+    );
+  }
+  return [];
+}
+function checkPatternContains(section, rule, filePath, ruleSource, formattedRule) {
+  const text = getFullSectionText(section);
+  const found = new RegExp(rule.pattern, "m").test(text);
+  if (rule.prohibited) {
+    if (found) {
+      return [
+        {
+          severity: "warning",
+          code: "schema-prohibited",
+          message: `Section '${section.headingText}' contains prohibited content: ${rule.label ?? rule.pattern}`,
+          filePath,
+          line: section.heading.position?.start.line,
+          ruleSource,
+          rule: formattedRule
+        }
+      ];
+    }
+    return [];
+  }
+  if (found) return [];
+  if (rule.required !== false) {
+    return [
+      {
+        severity: "error",
+        code: "schema-missing-content",
+        message: `Section '${section.headingText}' missing required content: ${rule.label ?? rule.pattern}`,
+        filePath,
+        line: section.heading.position?.start.line,
+        ruleSource,
+        rule: formattedRule
+      }
+    ];
+  }
+  return [];
+}
+function checkListContains(section, rule, filePath, ruleSource, formattedRule) {
+  const items = collectAllListItems(section);
+  const regex = new RegExp(rule.list.pattern);
+  const count = items.filter((item) => regex.test(item)).length;
+  if (rule.list.min !== void 0 && count < rule.list.min) {
+    return [
+      {
+        severity: "error",
+        code: "schema-missing-content",
+        message: `Section '${section.headingText}' has ${count} matching ${rule.list.label ?? "list items"}, expected at least ${rule.list.min}`,
+        filePath,
+        line: section.heading.position?.start.line,
+        ruleSource,
+        rule: formattedRule
+      }
+    ];
+  }
+  return [];
+}
+function checkTableContains(section, rule, filePath, ruleSource, formattedRule) {
+  const tables = collectAllTables(section);
+  if (tables.length === 0) {
+    return [
+      {
+        severity: "error",
+        code: "schema-missing-content",
+        message: `Section '${section.headingText}' missing required table${rule.table.heading ? ` (${rule.table.heading})` : ""}`,
+        filePath,
+        line: section.heading.position?.start.line,
+        ruleSource,
+        rule: formattedRule
+      }
+    ];
+  }
+  let matched;
+  let firstMismatch;
+  for (const table of tables) {
+    const headerRow = table.children[0];
+    if (!headerRow) continue;
+    const headers = headerRow.children.map(
+      (cell) => extractText(cell.children).trim()
+    );
+    if (rule.table.columns.every((col) => headers.includes(col))) {
+      matched = table;
+      break;
+    }
+    if (!firstMismatch) {
+      firstMismatch = { table, headers };
+    }
+  }
+  if (!matched) {
+    const mm = firstMismatch;
+    return [
+      {
+        severity: "error",
+        code: "schema-table-columns",
+        message: `No table in '${section.headingText}' has columns [${rule.table.columns.join(", ")}]${mm ? `, found [${mm.headers.join(", ")}]` : ""}`,
+        filePath,
+        line: mm?.table.position?.start.line ?? section.heading.position?.start.line,
+        ruleSource,
+        rule: formattedRule
+      }
+    ];
+  }
+  const findings = [];
+  const dataRows = matched.children.length - 1;
+  if (rule.table["min-rows"] !== void 0 && dataRows < rule.table["min-rows"]) {
+    findings.push({
+      severity: "error",
+      code: "schema-missing-content",
+      message: `Table in '${section.headingText}' has ${dataRows} data rows, expected at least ${rule.table["min-rows"]}`,
+      filePath,
+      line: matched.position?.start.line,
+      ruleSource,
+      rule: formattedRule
+    });
+  }
+  return findings;
+}
+function checkCodeBlockContains(section, rule, filePath, ruleSource, formattedRule) {
+  if (collectAllCodeBlocks(section).length > 0) return [];
+  return [
+    {
+      severity: "error",
+      code: "schema-missing-content",
+      message: `Section '${section.headingText}' missing required ${rule.label ?? "code block"}`,
+      filePath,
+      line: section.heading.position?.start.line,
+      ruleSource,
+      rule: formattedRule
+    }
+  ];
+}
+function checkHeadingOrText(section, rule, filePath, ruleSource, formattedRule) {
+  const needle = rule["heading-or-text"].toUpperCase();
+  if (section.children.some((c) => c.headingText.toUpperCase().includes(needle))) return [];
+  if (getFullSectionText(section).toUpperCase().includes(needle)) return [];
+  if (rule.required !== false) {
+    return [
+      {
+        severity: "error",
+        code: "schema-missing-content",
+        message: `Section '${section.headingText}' missing required heading or text: '${rule["heading-or-text"]}'`,
+        filePath,
+        line: section.heading.position?.start.line,
+        ruleSource,
+        rule: formattedRule
+      }
+    ];
+  }
+  return [];
+}
+function evaluateWhenCondition(when, headingText) {
+  if (when["heading-matches"]) {
+    if (!new RegExp(when["heading-matches"]).test(headingText)) return false;
+  }
+  if (when["heading-not-matches"]) {
+    if (new RegExp(when["heading-not-matches"]).test(headingText)) return false;
+  }
+  return true;
+}
+function checkProhibited(content, prohibited, filePath, ruleSource) {
+  const findings = [];
+  const lines = content.split("\n");
+  for (const pattern of prohibited) {
+    const regex = new RegExp(escapeRegex(pattern));
+    let inCodeBlock = false;
+    for (const [i, line] of lines.entries()) {
+      if (line.startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+        continue;
+      }
+      if (inCodeBlock) continue;
+      if (regex.test(line)) {
+        findings.push({
+          severity: "warning",
+          code: "schema-prohibited",
+          message: `Prohibited formatting '${pattern}' found`,
+          filePath,
+          line: i + 1,
+          ruleSource,
+          rule: formatProhibitedRule(pattern)
+        });
+        break;
+      }
+    }
+  }
+  return findings;
+}
+function getFullSectionText(section) {
+  let text = section.contentNodes.map(nodeToText).join("\n");
+  for (const child of section.children) {
+    text += `
+${child.headingText}
+${getFullSectionText(child)}`;
+  }
+  return text;
+}
+function nodeToText(node) {
+  if ("value" in node) return node.value;
+  if ("children" in node) {
+    return node.children.map((c) => nodeToText(c)).join("");
+  }
+  return "";
+}
+function extractListItems(nodes) {
+  const items = [];
+  for (const node of nodes) {
+    if (node.type === "list") {
+      for (const item of node.children) {
+        const raw = nodeToText(item);
+        const li = item;
+        if (li.checked === true) {
+          items.push(`[x] ${raw}`);
+        } else if (li.checked === false) {
+          items.push(`[ ] ${raw}`);
+        } else {
+          items.push(raw);
+        }
+      }
+    }
+  }
+  return items;
+}
+function collectAllListItems(section) {
+  const items = extractListItems(section.contentNodes);
+  for (const child of section.children) items.push(...collectAllListItems(child));
+  return items;
+}
+function collectAllTables(section) {
+  const tables = section.contentNodes.filter((n) => n.type === "table");
+  for (const child of section.children) tables.push(...collectAllTables(child));
+  return tables;
+}
+function collectAllCodeBlocks(section) {
+  const blocks = section.contentNodes.filter((n) => n.type === "code");
+  for (const child of section.children) blocks.push(...collectAllCodeBlocks(child));
+  return blocks;
+}
+
+// src/core/check/spec-parser.ts
+import { readFile as readFile4 } from "fs/promises";
+import { basename } from "path";
+async function parseSpecs(config) {
+  const files = await collectSpecFiles(config.specGlobs, config.ignore);
+  const specFiles = [];
+  const requirementIds = /* @__PURE__ */ new Set();
+  const acIds = /* @__PURE__ */ new Set();
+  const propertyIds = /* @__PURE__ */ new Set();
+  const componentNames = /* @__PURE__ */ new Set();
+  const idLocations = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const specFile = await parseSpecFile(filePath, config.crossRefPatterns);
+    if (specFile) {
+      specFiles.push(specFile);
+      for (const id of specFile.requirementIds) requirementIds.add(id);
+      for (const id of specFile.acIds) acIds.add(id);
+      for (const id of specFile.propertyIds) propertyIds.add(id);
+      for (const name of specFile.componentNames) componentNames.add(name);
+      for (const [id, loc] of specFile.idLocations ?? []) {
+        idLocations.set(id, loc);
+      }
+    }
+  }
+  const allIds = /* @__PURE__ */ new Set([...requirementIds, ...acIds, ...propertyIds, ...componentNames]);
+  return { requirementIds, acIds, propertyIds, componentNames, allIds, specFiles, idLocations };
+}
+async function parseSpecFile(filePath, crossRefPatterns) {
+  let content;
+  try {
+    content = await readFile4(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const code = extractCodePrefix(filePath);
+  const lines = content.split("\n");
+  const requirementIds = [];
+  const acIds = [];
+  const propertyIds = [];
+  const componentNames = [];
+  const crossRefs = [];
+  const idLocations = /* @__PURE__ */ new Map();
+  const reqIdRegex = /^###\s+([A-Z][A-Z0-9]*-\d+(?:\.\d+)?)\s*:/;
+  const acIdRegex = /^-\s+\[[ x]\]\s+([A-Z][A-Z0-9]*-\d+(?:\.\d+)?_AC-\d+)\s/;
+  const propIdRegex = /^-\s+([A-Z][A-Z0-9]*_P-\d+)\s/;
+  const componentRegex = /^###\s+([A-Z][A-Z0-9]*-[A-Za-z][A-Za-z0-9]*(?:[A-Z][a-z0-9]*)*)\s*$/;
+  for (const [i, line] of lines.entries()) {
+    const lineNum = i + 1;
+    const reqMatch = reqIdRegex.exec(line);
+    if (reqMatch?.[1]) {
+      requirementIds.push(reqMatch[1]);
+      idLocations.set(reqMatch[1], { filePath, line: lineNum });
+    }
+    const acMatch = acIdRegex.exec(line);
+    if (acMatch?.[1]) {
+      acIds.push(acMatch[1]);
+      idLocations.set(acMatch[1], { filePath, line: lineNum });
+    }
+    const propMatch = propIdRegex.exec(line);
+    if (propMatch?.[1]) {
+      propertyIds.push(propMatch[1]);
+      idLocations.set(propMatch[1], { filePath, line: lineNum });
+    }
+    const compMatch = componentRegex.exec(line);
+    if (compMatch?.[1]) {
+      if (!reqIdRegex.test(line)) {
+        componentNames.push(compMatch[1]);
+        idLocations.set(compMatch[1], { filePath, line: lineNum });
+      }
+    }
+    for (const pattern of crossRefPatterns) {
+      const patIdx = line.indexOf(pattern);
+      if (patIdx !== -1) {
+        const afterPattern = line.slice(patIdx + pattern.length);
+        const ids = extractIdsFromText(afterPattern);
+        if (ids.length > 0) {
+          const type = pattern.toLowerCase().includes("implements") ? "implements" : "validates";
+          crossRefs.push({ type, ids, filePath, line: i + 1 });
+        }
+      }
+    }
+  }
+  return {
+    filePath,
+    code,
+    requirementIds,
+    acIds,
+    propertyIds,
+    componentNames,
+    crossRefs,
+    idLocations
+  };
+}
+function extractCodePrefix(filePath) {
+  const name = basename(filePath, ".md");
+  const match = /^(?:REQ|DESIGN|FEAT|EXAMPLES|API)-([A-Z][A-Z0-9]*)-/.exec(name);
+  if (match?.[1]) return match[1];
+  return "";
+}
+function extractIdsFromText(text) {
+  const idRegex = /[A-Z][A-Z0-9]*-\d+(?:\.\d+)?(?:_AC-\d+)?|[A-Z][A-Z0-9]*_P-\d+/g;
+  const ids = [];
+  let match = idRegex.exec(text);
+  while (match !== null) {
+    ids.push(match[0]);
+    match = idRegex.exec(text);
+  }
+  return ids;
+}
+async function collectSpecFiles(specGlobs, ignore) {
+  return collectFiles(specGlobs, ignore);
+}
+
+// src/core/check/spec-spec-checker.ts
+function checkSpecAgainstSpec(specs, markers, config) {
+  const findings = [];
+  for (const specFile of specs.specFiles) {
+    for (const crossRef of specFile.crossRefs) {
+      for (const refId of crossRef.ids) {
+        if (!specs.allIds.has(refId)) {
+          findings.push({
+            severity: "error",
+            code: "broken-cross-ref",
+            message: `Cross-reference '${refId}' (${crossRef.type}) not found in any spec file`,
+            filePath: crossRef.filePath,
+            line: crossRef.line,
+            id: refId
+          });
+        }
+      }
+    }
+  }
+  if (!config.specOnly) {
+    const referencedCodes = /* @__PURE__ */ new Set();
+    for (const marker of markers.markers) {
+      const codeMatch = /^([A-Z][A-Z0-9]*)[-_]/.exec(marker.id);
+      if (codeMatch?.[1]) {
+        referencedCodes.add(codeMatch[1]);
+      }
+    }
+    for (const specFile of specs.specFiles) {
+      for (const crossRef of specFile.crossRefs) {
+        for (const refId of crossRef.ids) {
+          const codeMatch = /^([A-Z][A-Z0-9]*)[-_]/.exec(refId);
+          if (codeMatch?.[1]) {
+            referencedCodes.add(codeMatch[1]);
+          }
+        }
+      }
+    }
+    for (const specFile of specs.specFiles) {
+      if (!specFile.code) continue;
+      if (!referencedCodes.has(specFile.code)) {
+        findings.push({
+          severity: "warning",
+          code: "orphaned-spec",
+          message: `Spec file code '${specFile.code}' is not referenced by any other spec or code marker`,
+          filePath: specFile.filePath,
+          id: specFile.code
+        });
+      }
+    }
+  }
+  return { findings };
+}
+
+// src/core/check/types.ts
+var DEFAULT_CHECK_CONFIG = {
+  specGlobs: [".awa/specs/**/*.md"],
+  codeGlobs: ["src/**/*.{ts,js,tsx,jsx,py,go,rs,java,cs}"],
+  ignore: ["node_modules/**", "dist/**"],
+  ignoreMarkers: [],
+  markers: ["@awa-impl", "@awa-test", "@awa-component"],
+  idPattern: "([A-Z][A-Z0-9]*-\\d+(?:\\.\\d+)?(?:_AC-\\d+)?|[A-Z][A-Z0-9]*_P-\\d+)",
+  crossRefPatterns: ["IMPLEMENTS:", "VALIDATES:"],
+  format: "text",
+  schemaDir: ".awa/.agent/schemas",
+  schemaEnabled: true,
+  allowWarnings: false,
+  specOnly: false
+};
 
 // src/core/config.ts
 import { parse } from "smol-toml";
@@ -50,9 +1205,9 @@ var GenerationError = class extends Error {
 };
 
 // src/utils/fs.ts
-import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile as readFile5, rm, stat, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
@@ -66,10 +1221,10 @@ async function pathExists(path) {
   }
 }
 async function readTextFile(path) {
-  return readFile(path, "utf-8");
+  return readFile5(path, "utf-8");
 }
 async function readBinaryFile(path) {
-  return readFile(path);
+  return readFile5(path);
 }
 async function writeTextFile(path, content) {
   await ensureDir(dirname(path));
@@ -78,7 +1233,7 @@ async function writeTextFile(path, content) {
 async function* walkDirectory(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name.startsWith("_")) {
         continue;
@@ -93,15 +1248,15 @@ async function* walkDirectory(dir) {
   }
 }
 function getCacheDir() {
-  return join(homedir(), ".cache", "awa", "templates");
+  return join2(homedir(), ".cache", "awa", "templates");
 }
 function getTemplateDir() {
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
   if (currentDir.includes("/dist")) {
-    return join(dirname(currentDir), "templates");
+    return join2(dirname(currentDir), "templates");
   }
-  return join(currentDir, "..", "..", "templates");
+  return join2(currentDir, "..", "..", "templates");
 }
 async function rmDir(dirPath) {
   await rm(dirPath, { recursive: true, force: true });
@@ -111,67 +1266,67 @@ async function deleteFile(filePath) {
 }
 
 // src/utils/logger.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 var Logger = class {
   info(message) {
-    console.log(chalk.blue("\u2139"), message);
+    console.log(chalk2.blue("\u2139"), message);
   }
   success(message) {
-    console.log(chalk.green("\u2714"), message);
+    console.log(chalk2.green("\u2714"), message);
   }
   warn(message) {
-    console.warn(chalk.yellow("\u26A0"), message);
+    console.warn(chalk2.yellow("\u26A0"), message);
   }
   error(message) {
-    console.error(chalk.red("\u2716"), message);
+    console.error(chalk2.red("\u2716"), message);
   }
   fileAction(action) {
     const { type, outputPath } = action;
     switch (type) {
       case "create":
-        console.log(chalk.green("  + "), chalk.dim(outputPath));
+        console.log(chalk2.green("  + "), chalk2.dim(outputPath));
         break;
       case "overwrite":
-        console.log(chalk.yellow("  ~ "), chalk.dim(outputPath));
+        console.log(chalk2.yellow("  ~ "), chalk2.dim(outputPath));
         break;
       case "skip-user":
-        console.log(chalk.blue("  - "), chalk.dim(outputPath), chalk.dim("(skipped)"));
+        console.log(chalk2.blue("  - "), chalk2.dim(outputPath), chalk2.dim("(skipped)"));
         break;
       case "skip-empty":
-        console.log(chalk.dim("  \xB7 "), chalk.dim(outputPath), chalk.dim("(empty)"));
+        console.log(chalk2.dim("  \xB7 "), chalk2.dim(outputPath), chalk2.dim("(empty)"));
         break;
       case "skip-equal":
-        console.log(chalk.dim("  = "), chalk.dim(outputPath), chalk.dim("(unchanged)"));
+        console.log(chalk2.dim("  = "), chalk2.dim(outputPath), chalk2.dim("(unchanged)"));
         break;
       case "delete":
-        console.log(chalk.red("  \u2716 "), chalk.dim(outputPath), chalk.red("(deleted)"));
+        console.log(chalk2.red("  \u2716 "), chalk2.dim(outputPath), chalk2.red("(deleted)"));
         break;
     }
   }
   // @awa-impl: GEN-9_AC-1, GEN-9_AC-2, GEN-9_AC-3, GEN-9_AC-4, GEN-9_AC-5, GEN-9_AC-6
   summary(result) {
     console.log("");
-    console.log(chalk.bold("Summary:"));
+    console.log(chalk2.bold("Summary:"));
     if (result.created === 0 && result.overwritten === 0 && result.deleted === 0) {
-      console.log(chalk.yellow("  \u26A0 No files were created, overwritten, or deleted"));
+      console.log(chalk2.yellow("  \u26A0 No files were created, overwritten, or deleted"));
     }
     if (result.created > 0) {
-      console.log(chalk.green(`  Created: ${result.created}`));
+      console.log(chalk2.green(`  Created: ${result.created}`));
     }
     if (result.overwritten > 0) {
-      console.log(chalk.yellow(`  Overwritten: ${result.overwritten}`));
+      console.log(chalk2.yellow(`  Overwritten: ${result.overwritten}`));
     }
     if (result.deleted > 0) {
-      console.log(chalk.red(`  Deleted: ${result.deleted}`));
+      console.log(chalk2.red(`  Deleted: ${result.deleted}`));
     }
     if (result.skippedEqual > 0) {
-      console.log(chalk.dim(`  Skipped (equal): ${result.skippedEqual}`));
+      console.log(chalk2.dim(`  Skipped (equal): ${result.skippedEqual}`));
     }
     if (result.skippedUser > 0) {
-      console.log(chalk.blue(`  Skipped (user): ${result.skippedUser}`));
+      console.log(chalk2.blue(`  Skipped (user): ${result.skippedUser}`));
     }
     if (result.skippedEmpty > 0) {
-      console.log(chalk.dim(`  Skipped (empty): ${result.skippedEmpty}`));
+      console.log(chalk2.dim(`  Skipped (empty): ${result.skippedEmpty}`));
     }
     console.log("");
   }
@@ -179,13 +1334,13 @@ var Logger = class {
   diffLine(line, type) {
     switch (type) {
       case "add":
-        console.log(chalk.green(line));
+        console.log(chalk2.green(line));
         break;
       case "remove":
-        console.log(chalk.red(line));
+        console.log(chalk2.red(line));
         break;
       case "context":
-        console.log(chalk.dim(line));
+        console.log(chalk2.dim(line));
         break;
     }
   }
@@ -194,26 +1349,26 @@ var Logger = class {
     console.log("");
     const filesCompared = result.identical + result.modified + result.newFiles + result.extraFiles + result.binaryDiffers + result.deleteListed;
     const differences = result.modified + result.newFiles + result.extraFiles + result.binaryDiffers + result.deleteListed;
-    console.log(chalk.bold(`${filesCompared} files compared, ${differences} differences`));
+    console.log(chalk2.bold(`${filesCompared} files compared, ${differences} differences`));
     if (!result.hasDifferences) {
-      console.log(chalk.green("\u2714 No differences found"));
+      console.log(chalk2.green("\u2714 No differences found"));
     }
-    console.log(chalk.bold("Summary:"));
-    console.log(chalk.dim(`  Identical: ${result.identical}`));
+    console.log(chalk2.bold("Summary:"));
+    console.log(chalk2.dim(`  Identical: ${result.identical}`));
     if (result.modified > 0) {
-      console.log(chalk.yellow(`  Modified: ${result.modified}`));
+      console.log(chalk2.yellow(`  Modified: ${result.modified}`));
     }
     if (result.newFiles > 0) {
-      console.log(chalk.green(`  New: ${result.newFiles}`));
+      console.log(chalk2.green(`  New: ${result.newFiles}`));
     }
     if (result.extraFiles > 0) {
-      console.log(chalk.red(`  Extra: ${result.extraFiles}`));
+      console.log(chalk2.red(`  Extra: ${result.extraFiles}`));
     }
     if (result.binaryDiffers > 0) {
-      console.log(chalk.red(`  Binary differs: ${result.binaryDiffers}`));
+      console.log(chalk2.red(`  Binary differs: ${result.binaryDiffers}`));
     }
     if (result.deleteListed > 0) {
-      console.log(chalk.red(`  Delete listed: ${result.deleteListed}`));
+      console.log(chalk2.red(`  Delete listed: ${result.deleteListed}`));
     }
     console.log("");
   }
@@ -364,6 +1519,53 @@ var ConfigLoader = class {
         }
         config["list-unknown"] = parsed["list-unknown"];
       }
+      if (parsed.check !== void 0) {
+        if (parsed.check === null || typeof parsed.check !== "object" || Array.isArray(parsed.check)) {
+          throw new ConfigError(
+            `Invalid type for 'check': expected table`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.check = parsed.check;
+      }
+      if (parsed.overlay !== void 0) {
+        if (!Array.isArray(parsed.overlay) || !parsed.overlay.every((o) => typeof o === "string")) {
+          throw new ConfigError(
+            `Invalid type for 'overlay': expected array of strings`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.overlay = parsed.overlay;
+      }
+      if (parsed.targets !== void 0) {
+        if (parsed.targets === null || typeof parsed.targets !== "object" || Array.isArray(parsed.targets)) {
+          throw new ConfigError(
+            `Invalid type for 'targets': expected table of target sections`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        const targets = {};
+        for (const [targetName, targetValue] of Object.entries(
+          parsed.targets
+        )) {
+          if (targetValue === null || typeof targetValue !== "object" || Array.isArray(targetValue)) {
+            throw new ConfigError(
+              `Invalid target '${targetName}': expected table`,
+              "INVALID_TYPE",
+              pathToLoad
+            );
+          }
+          targets[targetName] = this.parseTargetSection(
+            targetValue,
+            targetName,
+            pathToLoad
+          );
+        }
+        config.targets = targets;
+      }
       const knownKeys = /* @__PURE__ */ new Set([
         "output",
         "template",
@@ -375,7 +1577,10 @@ var ConfigLoader = class {
         "dry-run",
         "delete",
         "refresh",
-        "list-unknown"
+        "list-unknown",
+        "check",
+        "targets",
+        "overlay"
       ]);
       for (const key of Object.keys(parsed)) {
         if (!knownKeys.has(key)) {
@@ -415,6 +1620,9 @@ var ConfigLoader = class {
     const enableDelete = cli.delete ?? file?.delete ?? false;
     const refresh = cli.refresh ?? file?.refresh ?? false;
     const listUnknown = cli.listUnknown ?? file?.["list-unknown"] ?? false;
+    const overlay = cli.overlay ?? file?.overlay ?? [];
+    const json = cli.json ?? false;
+    const summary = cli.summary ?? false;
     return {
       output,
       template,
@@ -426,20 +1634,260 @@ var ConfigLoader = class {
       delete: enableDelete,
       refresh,
       presets,
-      listUnknown
+      listUnknown,
+      overlay,
+      json,
+      summary
     };
   }
+  // Parse a [targets.<name>] section, validating allowed keys and types
+  parseTargetSection(section, targetName, configPath) {
+    const target = {};
+    const allowedKeys = /* @__PURE__ */ new Set(["output", "template", "features", "preset", "remove-features"]);
+    for (const key of Object.keys(section)) {
+      if (!allowedKeys.has(key)) {
+        logger.warn(`Unknown option in target '${targetName}': '${key}'`);
+      }
+    }
+    if (section.output !== void 0) {
+      if (typeof section.output !== "string") {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.output': expected string, got ${typeof section.output}`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.output = section.output;
+    }
+    if (section.template !== void 0) {
+      if (typeof section.template !== "string") {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.template': expected string, got ${typeof section.template}`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.template = section.template;
+    }
+    if (section.features !== void 0) {
+      if (!Array.isArray(section.features) || !section.features.every((f) => typeof f === "string")) {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.features': expected array of strings`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.features = section.features;
+    }
+    if (section.preset !== void 0) {
+      if (!Array.isArray(section.preset) || !section.preset.every((p) => typeof p === "string")) {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.preset': expected array of strings`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.preset = section.preset;
+    }
+    if (section["remove-features"] !== void 0) {
+      if (!Array.isArray(section["remove-features"]) || !section["remove-features"].every((f) => typeof f === "string")) {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.remove-features': expected array of strings`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target["remove-features"] = section["remove-features"];
+    }
+    return target;
+  }
+  // Resolve a target by merging target config with root config (target overrides root via nullish coalescing)
+  resolveTarget(targetName, fileConfig) {
+    const targets = fileConfig.targets;
+    if (!targets || Object.keys(targets).length === 0) {
+      throw new ConfigError(
+        "No targets defined in configuration. Add [targets.<name>] sections to .awa.toml.",
+        "NO_TARGETS",
+        null
+      );
+    }
+    const target = targets[targetName];
+    if (!target) {
+      throw new ConfigError(
+        `Unknown target: '${targetName}'. Available targets: ${Object.keys(targets).join(", ")}`,
+        "UNKNOWN_TARGET",
+        null
+      );
+    }
+    return {
+      ...fileConfig,
+      output: target.output ?? fileConfig.output,
+      template: target.template ?? fileConfig.template,
+      features: target.features ?? fileConfig.features,
+      preset: target.preset ?? fileConfig.preset,
+      "remove-features": target["remove-features"] ?? fileConfig["remove-features"],
+      targets: void 0
+      // Don't propagate targets into resolved config
+    };
+  }
+  // Get all target names from config
+  getTargetNames(fileConfig) {
+    if (!fileConfig?.targets) {
+      return [];
+    }
+    return Object.keys(fileConfig.targets);
+  }
+};
+var configLoader = new ConfigLoader();
+
+// src/commands/check.ts
+async function checkCommand(cliOptions) {
+  try {
+    const fileConfig = await configLoader.load(cliOptions.config ?? null);
+    const config = buildCheckConfig(fileConfig, cliOptions);
+    const emptyMarkers = {
+      markers: [],
+      findings: []
+    };
+    const [markers, specs, ruleSets] = await Promise.all([
+      config.specOnly ? Promise.resolve(emptyMarkers) : scanMarkers(config),
+      parseSpecs(config),
+      config.schemaEnabled ? loadRules(config.schemaDir) : Promise.resolve([])
+    ]);
+    const codeSpecResult = config.specOnly ? { findings: [] } : checkCodeAgainstSpec(markers, specs, config);
+    const specSpecResult = checkSpecAgainstSpec(specs, markers, config);
+    const schemaResult = config.schemaEnabled && ruleSets.length > 0 ? await checkSchemasAsync(specs.specFiles, ruleSets) : { findings: [] };
+    const combinedFindings = [
+      ...markers.findings,
+      ...codeSpecResult.findings,
+      ...specSpecResult.findings,
+      ...schemaResult.findings
+    ];
+    const allFindings = config.allowWarnings ? combinedFindings : combinedFindings.map(
+      (f) => f.severity === "warning" ? { ...f, severity: "error" } : f
+    );
+    report(allFindings, config.format);
+    const hasErrors = allFindings.some((f) => f.severity === "error");
+    return hasErrors ? 1 : 0;
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    return 2;
+  }
+}
+function buildCheckConfig(fileConfig, cliOptions) {
+  const section = fileConfig?.check;
+  const specGlobs = toStringArray(section?.["spec-globs"]) ?? [...DEFAULT_CHECK_CONFIG.specGlobs];
+  const codeGlobs = toStringArray(section?.["code-globs"]) ?? [...DEFAULT_CHECK_CONFIG.codeGlobs];
+  const markers = toStringArray(section?.markers) ?? [...DEFAULT_CHECK_CONFIG.markers];
+  const crossRefPatterns = toStringArray(section?.["cross-ref-patterns"]) ?? [
+    ...DEFAULT_CHECK_CONFIG.crossRefPatterns
+  ];
+  const idPattern = typeof section?.["id-pattern"] === "string" ? section["id-pattern"] : DEFAULT_CHECK_CONFIG.idPattern;
+  const configIgnore = toStringArray(section?.ignore) ?? [...DEFAULT_CHECK_CONFIG.ignore];
+  const cliIgnore = cliOptions.ignore ?? [];
+  const ignore = [...configIgnore, ...cliIgnore];
+  const ignoreMarkers = toStringArray(section?.["ignore-markers"]) ?? [
+    ...DEFAULT_CHECK_CONFIG.ignoreMarkers
+  ];
+  const format = cliOptions.format === "json" ? "json" : section?.format === "json" ? "json" : DEFAULT_CHECK_CONFIG.format;
+  const schemaDir = typeof section?.["schema-dir"] === "string" ? section["schema-dir"] : DEFAULT_CHECK_CONFIG.schemaDir;
+  const schemaEnabled = typeof section?.["schema-enabled"] === "boolean" ? section["schema-enabled"] : DEFAULT_CHECK_CONFIG.schemaEnabled;
+  const allowWarnings = cliOptions.allowWarnings === true ? true : typeof section?.["allow-warnings"] === "boolean" ? section["allow-warnings"] : DEFAULT_CHECK_CONFIG.allowWarnings;
+  const specOnly = cliOptions.specOnly === true ? true : typeof section?.["spec-only"] === "boolean" ? section["spec-only"] : DEFAULT_CHECK_CONFIG.specOnly;
+  return {
+    specGlobs,
+    codeGlobs,
+    ignore,
+    ignoreMarkers,
+    markers,
+    idPattern,
+    crossRefPatterns,
+    format,
+    schemaDir,
+    schemaEnabled,
+    allowWarnings,
+    specOnly
+  };
+}
+function toStringArray(value) {
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  return null;
+}
+
+// src/commands/diff.ts
+import { intro, outro } from "@clack/prompts";
+
+// src/core/batch-runner.ts
+var BatchRunner = class {
+  // Resolve all targets or a single named target from config
+  resolveTargets(cli, fileConfig, mode, targetName) {
+    if (!fileConfig) {
+      throw new ConfigError(
+        "No configuration file found. --all and --target require a config file with [targets.*] sections.",
+        "NO_TARGETS",
+        null
+      );
+    }
+    const targetNames = configLoader.getTargetNames(fileConfig);
+    if (targetNames.length === 0) {
+      throw new ConfigError(
+        "No targets defined in configuration. Add [targets.<name>] sections to .awa.toml.",
+        "NO_TARGETS",
+        null
+      );
+    }
+    const namesToProcess = mode === "all" ? targetNames : [targetName];
+    const results = [];
+    for (const name of namesToProcess) {
+      const resolved = configLoader.resolveTarget(name, fileConfig);
+      const targetCli = {
+        ...cli,
+        output: mode === "all" ? void 0 : cli.output
+      };
+      let options;
+      try {
+        options = configLoader.merge(targetCli, resolved);
+      } catch (error) {
+        if (error instanceof ConfigError && error.code === "MISSING_OUTPUT") {
+          throw new ConfigError(
+            `Target '${name}' has no output directory. Specify 'output' in [targets.${name}] or in the root config.`,
+            "MISSING_OUTPUT",
+            null
+          );
+        }
+        throw error;
+      }
+      results.push({ targetName: name, options });
+    }
+    return results;
+  }
+  // Log a message prefixed with target name
+  logForTarget(targetName, message) {
+    logger.info(`[${targetName}] ${message}`);
+  }
+  warnForTarget(targetName, message) {
+    logger.warn(`[${targetName}] ${message}`);
+  }
+  errorForTarget(targetName, message) {
+    logger.error(`[${targetName}] ${message}`);
+  }
 };
-var configLoader = new ConfigLoader();
+var batchRunner = new BatchRunner();
 
 // src/core/differ.ts
 import { tmpdir } from "os";
-import { join as join4, relative as relative2 } from "path";
+import { join as join5, relative as relative2 } from "path";
 import { structuredPatch } from "diff";
 import { isBinaryFile as detectBinaryFile } from "isbinaryfile";
 
 // src/core/delete-list.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var DELETE_LIST_FILENAME = "_delete.txt";
 function parseDeleteList(content) {
   const entries = [];
@@ -466,7 +1914,7 @@ function resolveDeleteList(entries, activeFeatures) {
   return entries.filter((e) => e.features === void 0 || !e.features.some((f) => activeSet.has(f))).map((e) => e.path);
 }
 async function loadDeleteList(templatePath) {
-  const deleteListPath = join2(templatePath, DELETE_LIST_FILENAME);
+  const deleteListPath = join3(templatePath, DELETE_LIST_FILENAME);
   if (!await pathExists(deleteListPath)) {
     return [];
   }
@@ -475,12 +1923,12 @@ async function loadDeleteList(templatePath) {
 }
 
 // src/core/generator.ts
-import { join as join3, relative } from "path";
+import { join as join4, relative } from "path";
 
 // src/core/resolver.ts
 import { MultiSelectPrompt } from "@clack/core";
 import { isCancel, multiselect } from "@clack/prompts";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var _unicode = process.platform !== "win32";
 var _s = (c, fb) => _unicode ? c : fb;
 var _CHECKED = _s("\u25FC", "[+]");
@@ -490,20 +1938,20 @@ var _BAR = _s("\u2502", "|");
 var _BAR_END = _s("\u2514", "-");
 function _renderDeleteItem(opt, state) {
   const label = opt.label ?? opt.value;
-  const hint = opt.hint ? ` ${chalk2.dim(`(${opt.hint})`)}` : "";
+  const hint = opt.hint ? ` ${chalk3.dim(`(${opt.hint})`)}` : "";
   switch (state) {
     case "active":
-      return `${chalk2.cyan(_UNCHECKED_A)} ${label}${hint}`;
+      return `${chalk3.cyan(_UNCHECKED_A)} ${label}${hint}`;
     case "selected":
-      return `${chalk2.red(_CHECKED)} ${chalk2.dim(label)}${hint}`;
+      return `${chalk3.red(_CHECKED)} ${chalk3.dim(label)}${hint}`;
     case "active-selected":
-      return `${chalk2.red(_CHECKED)} ${label}${hint}`;
+      return `${chalk3.red(_CHECKED)} ${label}${hint}`;
     case "cancelled":
-      return chalk2.strikethrough(chalk2.dim(label));
+      return chalk3.strikethrough(chalk3.dim(label));
     case "submitted":
-      return chalk2.dim(label);
+      return chalk3.dim(label);
     default:
-      return `${chalk2.dim(_UNCHECKED)} ${chalk2.dim(label)}`;
+      return `${chalk3.dim(_UNCHECKED)} ${chalk3.dim(label)}`;
   }
 }
 async function deleteMultiselect(opts) {
@@ -514,8 +1962,8 @@ async function deleteMultiselect(opts) {
     required,
     render() {
       const self = this;
-      const header = `${chalk2.gray(_BAR)}
-${chalk2.cyan(_BAR)}  ${message}
+      const header = `${chalk3.gray(_BAR)}
+${chalk3.cyan(_BAR)}  ${message}
 `;
       const getState = (opt, idx) => {
         const active = idx === self.cursor;
@@ -527,16 +1975,16 @@ ${chalk2.cyan(_BAR)}  ${message}
       };
       switch (self.state) {
         case "submit":
-          return `${header}${chalk2.gray(_BAR)}  ` + (self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "submitted")).join(chalk2.dim(", ")) || chalk2.dim("none"));
+          return `${header}${chalk3.gray(_BAR)}  ` + (self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "submitted")).join(chalk3.dim(", ")) || chalk3.dim("none"));
         case "cancel": {
-          const cancelled = self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "cancelled")).join(chalk2.dim(", "));
-          return `${header}${chalk2.gray(_BAR)}  ${cancelled.trim() ? `${cancelled}
-${chalk2.gray(_BAR)}` : chalk2.dim("none")}`;
+          const cancelled = self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "cancelled")).join(chalk3.dim(", "));
+          return `${header}${chalk3.gray(_BAR)}  ${cancelled.trim() ? `${cancelled}
+${chalk3.gray(_BAR)}` : chalk3.dim("none")}`;
         }
         default:
-          return `${header}${chalk2.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
-${chalk2.cyan(_BAR)}  `) + `
-${chalk2.cyan(_BAR_END)}
+          return `${header}${chalk3.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
+${chalk3.cyan(_BAR)}  `) + `
+${chalk3.cyan(_BAR_END)}
 `;
       }
     }
@@ -661,7 +2109,8 @@ var TemplateEngine = class {
     try {
       const templateContent = await readTextFile(templatePath);
       const rendered = await this.eta.renderStringAsync(templateContent, {
-        features: context.features
+        features: context.features,
+        version: context.version ?? ""
       });
       const trimmed = rendered.trim();
       const isEmpty = trimmed.length === 0;
@@ -703,7 +2152,10 @@ var FileGenerator = class {
     try {
       for await (const templateFile of this.walkTemplates(templatePath)) {
         const outputFile = this.computeOutputPath(templateFile, templatePath, outputPath);
-        const result = await templateEngine.render(templateFile, { features });
+        const result = await templateEngine.render(templateFile, {
+          features,
+          version: PACKAGE_INFO.version
+        });
         if (result.isEmpty && !result.isEmptyFileMarker) {
           actions.push({
             type: "skip-empty",
@@ -802,7 +2254,7 @@ var FileGenerator = class {
         const generatedOutputPaths = new Set(filesToProcess.map((f) => f.outputFile));
         const deleteCandidates = [];
         for (const relPath of deleteList) {
-          const absPath = join3(outputPath, relPath);
+          const absPath = join4(outputPath, relPath);
           if (generatedOutputPaths.has(absPath)) {
             logger.warn(
               `Delete list entry '${relPath}' conflicts with generated file \u2014 skipping deletion`
@@ -864,7 +2316,7 @@ var FileGenerator = class {
   // @awa-impl: GEN-1_AC-1, GEN-1_AC-2, GEN-1_AC-3
   computeOutputPath(templatePath, templateRoot, outputRoot) {
     const relativePath = relative(templateRoot, templatePath);
-    return join3(outputRoot, relativePath);
+    return join4(outputRoot, relativePath);
   }
 };
 var fileGenerator = new FileGenerator();
@@ -906,8 +2358,8 @@ var DiffEngine = class {
       }
       const files = [];
       for (const relPath of generatedFiles) {
-        const generatedFilePath = join4(tempPath, relPath);
-        const targetFilePath = join4(targetPath, relPath);
+        const generatedFilePath = join5(tempPath, relPath);
+        const targetFilePath = join5(targetPath, relPath);
         if (targetFiles.has(relPath)) {
           const fileDiff = await this.compareFiles(generatedFilePath, targetFilePath, relPath);
           files.push(fileDiff);
@@ -971,7 +2423,7 @@ var DiffEngine = class {
     const systemTemp = tmpdir();
     const timestamp = Date.now();
     const random = Math.random().toString(36).substring(2, 8);
-    const tempPath = join4(systemTemp, `awa-diff-${timestamp}-${random}`);
+    const tempPath = join5(systemTemp, `awa-diff-${timestamp}-${random}`);
     await ensureDir(tempPath);
     return tempPath;
   }
@@ -1073,16 +2525,69 @@ var FeatureResolver = class {
 };
 var featureResolver = new FeatureResolver();
 
+// src/core/json-output.ts
+function serializeGenerationResult(result) {
+  const actions = result.actions.map((action) => ({
+    type: action.type,
+    path: action.outputPath
+  }));
+  return {
+    actions,
+    counts: {
+      created: result.created,
+      overwritten: result.overwritten,
+      skipped: result.skipped,
+      deleted: result.deleted
+    }
+  };
+}
+function serializeDiffResult(result) {
+  const diffs = result.files.map((file) => {
+    const entry = {
+      path: file.relativePath,
+      status: file.status
+    };
+    if (file.unifiedDiff) {
+      entry.diff = file.unifiedDiff;
+    }
+    return entry;
+  });
+  return {
+    diffs,
+    counts: {
+      changed: result.modified,
+      new: result.newFiles,
+      matching: result.identical,
+      deleted: result.deleteListed
+    }
+  };
+}
+function formatGenerationSummary(result) {
+  return `created: ${result.created}, overwritten: ${result.overwritten}, skipped: ${result.skipped}, deleted: ${result.deleted}`;
+}
+function formatDiffSummary(result) {
+  return `changed: ${result.modified}, new: ${result.newFiles}, matching: ${result.identical}, deleted: ${result.deleteListed}`;
+}
+function writeJsonOutput(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+}
+
+// src/core/overlay.ts
+import { cp } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join7 } from "path";
+
 // src/core/template-resolver.ts
 import { createHash } from "crypto";
 import { rm as rm2 } from "fs/promises";
-import { isAbsolute, join as join5, resolve } from "path";
+import { isAbsolute, join as join6, resolve } from "path";
 import degit from "degit";
 var TemplateResolver = class {
   // @awa-impl: CLI-3_AC-2, TPL-10_AC-1
   async resolve(source, refresh) {
     if (!source) {
-      const bundledPath = join5(getTemplateDir(), "awa");
+      const bundledPath = join6(getTemplateDir(), "awa");
       return {
         type: "bundled",
         localPath: bundledPath,
@@ -1145,7 +2650,7 @@ var TemplateResolver = class {
       source
     );
   }
-  // @awa-impl: TPL-2_AC-1 through TPL-2_AC-6
+  // @awa-impl: TPL-2_AC-1, TPL-2_AC-2, TPL-2_AC-3, TPL-2_AC-4, TPL-2_AC-5, TPL-2_AC-6
   detectType(source) {
     if (source.startsWith(".") || source.startsWith("/") || source.startsWith("~")) {
       return "local";
@@ -1159,34 +2664,95 @@ var TemplateResolver = class {
   getCachePath(source) {
     const hash = createHash("sha256").update(source).digest("hex").substring(0, 16);
     const cacheDir = getCacheDir();
-    return join5(cacheDir, hash);
+    return join6(cacheDir, hash);
   }
 };
 var templateResolver = new TemplateResolver();
 
+// src/core/overlay.ts
+async function resolveOverlays(overlays, refresh) {
+  const dirs = [];
+  for (const source of overlays) {
+    const resolved = await templateResolver.resolve(source, refresh);
+    dirs.push(resolved.localPath);
+  }
+  return dirs;
+}
+async function buildMergedDir(baseDir, overlayDirs) {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  const tempPath = join7(tmpdir2(), `awa-overlay-${timestamp}-${random}`);
+  await ensureDir(tempPath);
+  await cp(baseDir, tempPath, { recursive: true });
+  for (const overlayDir of overlayDirs) {
+    await cp(overlayDir, tempPath, { recursive: true });
+  }
+  return tempPath;
+}
+
+// src/utils/file-watcher.ts
+import { watch } from "fs";
+
+// src/utils/debouncer.ts
+var Debouncer = class {
+  constructor(delayMs) {
+    this.delayMs = delayMs;
+  }
+  timer = null;
+  trigger(callback) {
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      callback();
+    }, this.delayMs);
+  }
+  cancel() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// src/utils/file-watcher.ts
+var FileWatcher = class {
+  watcher = null;
+  debouncer;
+  directory;
+  onChange;
+  constructor(options) {
+    this.directory = options.directory;
+    this.debouncer = new Debouncer(options.debounceMs ?? 300);
+    this.onChange = options.onChange;
+  }
+  start() {
+    this.watcher = watch(this.directory, { recursive: true }, () => {
+      this.debouncer.trigger(this.onChange);
+    });
+  }
+  stop() {
+    this.debouncer.cancel();
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+};
+
 // src/commands/diff.ts
-async function diffCommand(cliOptions) {
+async function runDiff(diffOptions, options, mergedDir) {
   try {
-    intro("awa CLI - Template Diff");
-    const fileConfig = await configLoader.load(cliOptions.config ?? null);
-    const options = configLoader.merge(cliOptions, fileConfig);
-    if (!await pathExists(options.output)) {
-      throw new DiffError(`Target directory does not exist: ${options.output}`);
+    const result = await diffEngine.diff(diffOptions);
+    if (options.json) {
+      writeJsonOutput(serializeDiffResult(result));
+      return result.hasDifferences ? 1 : 0;
+    }
+    if (options.summary) {
+      console.log(formatDiffSummary(result));
+      return result.hasDifferences ? 1 : 0;
     }
-    const targetPath = options.output;
-    const template = await templateResolver.resolve(options.template, options.refresh);
-    const features = featureResolver.resolve({
-      baseFeatures: [...options.features],
-      presetNames: [...options.preset],
-      removeFeatures: [...options.removeFeatures],
-      presetDefinitions: options.presets
-    });
-    const result = await diffEngine.diff({
-      templatePath: template.localPath,
-      targetPath,
-      features,
-      listUnknown: options.listUnknown
-    });
     for (const file of result.files) {
       switch (file.status) {
         case "modified":
@@ -1225,8 +2791,106 @@ async function diffCommand(cliOptions) {
       }
     }
     logger.diffSummary(result);
-    outro("Diff complete!");
     return result.hasDifferences ? 1 : 0;
+  } finally {
+    if (mergedDir) {
+      try {
+        await rmDir(mergedDir);
+      } catch {
+      }
+    }
+  }
+}
+async function prepareDiff(options) {
+  if (!await pathExists(options.output)) {
+    throw new DiffError(`Target directory does not exist: ${options.output}`);
+  }
+  const targetPath = options.output;
+  const template = await templateResolver.resolve(options.template, options.refresh);
+  const features = featureResolver.resolve({
+    baseFeatures: [...options.features],
+    presetNames: [...options.preset],
+    removeFeatures: [...options.removeFeatures],
+    presetDefinitions: options.presets
+  });
+  let mergedDir = null;
+  let templatePath = template.localPath;
+  if (options.overlay.length > 0) {
+    const overlayDirs = await resolveOverlays([...options.overlay], options.refresh);
+    mergedDir = await buildMergedDir(template.localPath, overlayDirs);
+    templatePath = mergedDir;
+  }
+  return {
+    diffOptions: {
+      templatePath,
+      targetPath,
+      features,
+      listUnknown: options.listUnknown
+    },
+    template,
+    mergedDir
+  };
+}
+async function diffCommand(cliOptions) {
+  try {
+    const fileConfig = await configLoader.load(cliOptions.config ?? null);
+    if (cliOptions.all || cliOptions.target) {
+      const mode = cliOptions.all ? "all" : "single";
+      const targets = batchRunner.resolveTargets(cliOptions, fileConfig, mode, cliOptions.target);
+      let hasDifferences = false;
+      for (const { targetName, options: options2 } of targets) {
+        batchRunner.logForTarget(targetName, "Starting diff...");
+        const { diffOptions: diffOptions2, mergedDir: mergedDir2 } = await prepareDiff(options2);
+        const exitCode = await runDiff(diffOptions2, options2, mergedDir2);
+        if (exitCode === 1) {
+          hasDifferences = true;
+        }
+        batchRunner.logForTarget(targetName, "Diff complete.");
+      }
+      outro("All targets diffed!");
+      return hasDifferences ? 1 : 0;
+    }
+    const options = configLoader.merge(cliOptions, fileConfig);
+    const silent = options.json || options.summary;
+    if (!silent) {
+      intro("awa CLI - Template Diff");
+    }
+    const { diffOptions, template, mergedDir } = await prepareDiff(options);
+    if (cliOptions.watch && template.type !== "local" && template.type !== "bundled") {
+      throw new DiffError("--watch is only supported with local template sources");
+    }
+    const result = await runDiff(diffOptions, options, mergedDir);
+    if (!cliOptions.watch) {
+      if (!silent) {
+        outro("Diff complete!");
+      }
+      return result;
+    }
+    logger.info(`Watching for changes in ${template.localPath}...`);
+    return new Promise((resolve2) => {
+      let running = false;
+      const watcher = new FileWatcher({
+        directory: template.localPath,
+        onChange: async () => {
+          if (running) return;
+          running = true;
+          try {
+            console.clear();
+            logger.info(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Change detected, re-running diff...`);
+            logger.info("---");
+            await runDiff(diffOptions, options, null);
+          } finally {
+            running = false;
+          }
+        }
+      });
+      watcher.start();
+      process.once("SIGINT", () => {
+        watcher.stop();
+        logger.info("\nWatch mode stopped.");
+        resolve2(0);
+      });
+    });
   } catch (error) {
     if (error instanceof Error) {
       logger.error(error.message);
@@ -1237,8 +2901,161 @@ async function diffCommand(cliOptions) {
   }
 }
 
+// src/commands/features.ts
+import { intro as intro2, outro as outro2 } from "@clack/prompts";
+
+// src/core/features/reporter.ts
+import chalk4 from "chalk";
+var FeaturesReporter = class {
+  // @awa-impl: DISC-6_AC-1, DISC-7_AC-1
+  /** Render the features report to stdout. */
+  report(options) {
+    const { scanResult, json, presets } = options;
+    if (json) {
+      this.reportJson(scanResult, presets);
+    } else {
+      this.reportTable(scanResult, presets);
+    }
+  }
+  // @awa-impl: DISC-6_AC-1
+  /** Build the JSON output object (also used by tests). */
+  buildJsonOutput(scanResult, presets) {
+    const output = {
+      features: scanResult.features.map((f) => ({
+        name: f.name,
+        files: f.files
+      })),
+      filesScanned: scanResult.filesScanned
+    };
+    if (presets && Object.keys(presets).length > 0) {
+      output.presets = presets;
+    }
+    return output;
+  }
+  reportJson(scanResult, presets) {
+    const output = this.buildJsonOutput(scanResult, presets);
+    console.log(JSON.stringify(output, null, 2));
+  }
+  // @awa-impl: DISC-7_AC-1
+  reportTable(scanResult, presets) {
+    const { features, filesScanned } = scanResult;
+    if (features.length === 0) {
+      console.log(chalk4.yellow("No feature flags found."));
+      console.log(chalk4.dim(`(${filesScanned} files scanned)`));
+      return;
+    }
+    console.log(chalk4.bold(`Feature flags (${features.length} found):
+`));
+    for (const feature of features) {
+      console.log(`  ${chalk4.cyan(feature.name)}`);
+      for (const file of feature.files) {
+        console.log(`    ${chalk4.dim(file)}`);
+      }
+    }
+    console.log("");
+    console.log(chalk4.dim(`${filesScanned} files scanned`));
+    if (presets && Object.keys(presets).length > 0) {
+      console.log("");
+      console.log(chalk4.bold("Presets (from .awa.toml):\n"));
+      for (const [name, flags] of Object.entries(presets)) {
+        console.log(`  ${chalk4.green(name)}: ${flags.join(", ")}`);
+      }
+    }
+  }
+};
+var featuresReporter = new FeaturesReporter();
+
+// src/core/features/scanner.ts
+import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
+import { join as join8, relative as relative3 } from "path";
+var FEATURE_PATTERN = /it\.features\.(?:includes|indexOf)\(\s*['"]([^'"]+)['"]\s*\)/g;
+async function* walkAllFiles(dir) {
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join8(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkAllFiles(fullPath);
+    } else if (entry.isFile()) {
+      yield fullPath;
+    }
+  }
+}
+var FeatureScanner = class {
+  // @awa-impl: DISC-1_AC-1, DISC-2_AC-1
+  /** Extract feature flag names from a single file's content. */
+  extractFlags(content) {
+    const flags = /* @__PURE__ */ new Set();
+    for (const match of content.matchAll(FEATURE_PATTERN)) {
+      if (match[1]) {
+        flags.add(match[1]);
+      }
+    }
+    return [...flags];
+  }
+  // @awa-impl: DISC-1_AC-1, DISC-2_AC-1, DISC-3_AC-1
+  /** Scan a template directory and return all discovered feature flags. */
+  async scan(templatePath) {
+    const flagToFiles = /* @__PURE__ */ new Map();
+    let filesScanned = 0;
+    for await (const filePath of walkAllFiles(templatePath)) {
+      filesScanned++;
+      try {
+        const content = await readFile6(filePath, "utf-8");
+        const flags = this.extractFlags(content);
+        const relPath = relative3(templatePath, filePath);
+        for (const flag of flags) {
+          const existing = flagToFiles.get(flag);
+          if (existing) {
+            existing.add(relPath);
+          } else {
+            flagToFiles.set(flag, /* @__PURE__ */ new Set([relPath]));
+          }
+        }
+      } catch {
+      }
+    }
+    const features = [...flagToFiles.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, files]) => ({
+      name,
+      files: [...files].sort()
+    }));
+    return { features, filesScanned };
+  }
+};
+var featureScanner = new FeatureScanner();
+
+// src/commands/features.ts
+async function featuresCommand(cliOptions) {
+  try {
+    if (!cliOptions.json) {
+      intro2("awa CLI - Feature Discovery");
+    }
+    const fileConfig = await configLoader.load(cliOptions.config ?? null);
+    const templateSource = cliOptions.template ?? fileConfig?.template ?? null;
+    const refresh = cliOptions.refresh ?? fileConfig?.refresh ?? false;
+    const template = await templateResolver.resolve(templateSource, refresh);
+    const scanResult = await featureScanner.scan(template.localPath);
+    const presets = fileConfig?.presets;
+    featuresReporter.report({
+      scanResult,
+      json: cliOptions.json ?? false,
+      presets
+    });
+    if (!cliOptions.json) {
+      outro2("Feature discovery complete!");
+    }
+    return 0;
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    return 1;
+  }
+}
+
 // src/commands/generate.ts
-import { intro as intro2, isCancel as isCancel2, multiselect as multiselect2, outro as outro2 } from "@clack/prompts";
+import { intro as intro3, isCancel as isCancel2, multiselect as multiselect2, outro as outro3 } from "@clack/prompts";
 var TOOL_FEATURES = [
   { value: "copilot", label: "GitHub Copilot" },
   { value: "claude", label: "Claude Code" },
@@ -1254,20 +3071,18 @@ var TOOL_FEATURES = [
   { value: "agents-md", label: "AGENTS.md (cross-tool)" }
 ];
 var TOOL_FEATURE_VALUES = new Set(TOOL_FEATURES.map((t) => t.value));
-async function generateCommand(cliOptions) {
-  try {
-    intro2("awa CLI - Template Generator");
-    const fileConfig = await configLoader.load(cliOptions.config ?? null);
-    const options = configLoader.merge(cliOptions, fileConfig);
-    const template = await templateResolver.resolve(options.template, options.refresh);
-    const features = featureResolver.resolve({
-      baseFeatures: [...options.features],
-      presetNames: [...options.preset],
-      removeFeatures: [...options.removeFeatures],
-      presetDefinitions: options.presets
-    });
+async function runGenerate(options, batchMode) {
+  const silent = options.json || options.summary;
+  const template = await templateResolver.resolve(options.template, options.refresh);
+  const features = featureResolver.resolve({
+    baseFeatures: [...options.features],
+    presetNames: [...options.preset],
+    removeFeatures: [...options.removeFeatures],
+    presetDefinitions: options.presets
+  });
+  if (!batchMode) {
     const hasToolFlag = features.some((f) => TOOL_FEATURE_VALUES.has(f));
-    if (!hasToolFlag) {
+    if (!hasToolFlag && !silent) {
       const selected = await multiselect2({
         message: "Select AI tools to generate for (space to toggle, enter to confirm):",
         options: TOOL_FEATURES.map((t) => ({ value: t.value, label: t.label })),
@@ -1279,22 +3094,74 @@ async function generateCommand(cliOptions) {
       }
       features.push(...selected);
     }
-    if (options.dryRun) {
+  }
+  const effectiveDryRun = options.json || options.dryRun;
+  if (!silent) {
+    if (effectiveDryRun) {
       logger.info("Running in dry-run mode (no files will be modified)");
     }
     if (options.force) {
       logger.info("Force mode enabled (existing files will be overwritten)");
     }
+  }
+  let mergedDir = null;
+  let templatePath = template.localPath;
+  if (options.overlay.length > 0) {
+    const overlayDirs = await resolveOverlays([...options.overlay], options.refresh);
+    mergedDir = await buildMergedDir(template.localPath, overlayDirs);
+    templatePath = mergedDir;
+  }
+  try {
     const result = await fileGenerator.generate({
-      templatePath: template.localPath,
+      templatePath,
       outputPath: options.output,
       features,
       force: options.force,
-      dryRun: options.dryRun,
+      dryRun: effectiveDryRun,
       delete: options.delete
     });
-    logger.summary(result);
-    outro2("Generation complete!");
+    if (options.json) {
+      writeJsonOutput(serializeGenerationResult(result));
+    } else if (options.summary) {
+      console.log(formatGenerationSummary(result));
+    } else {
+      logger.summary(result);
+    }
+  } finally {
+    if (mergedDir) {
+      try {
+        await rmDir(mergedDir);
+      } catch {
+      }
+    }
+  }
+}
+async function generateCommand(cliOptions) {
+  try {
+    const fileConfig = await configLoader.load(cliOptions.config ?? null);
+    if (!cliOptions.config && fileConfig === null) {
+      logger.info("Tip: create .awa.toml to save your options for next time.");
+    }
+    if (cliOptions.all || cliOptions.target) {
+      const mode = cliOptions.all ? "all" : "single";
+      const targets = batchRunner.resolveTargets(cliOptions, fileConfig, mode, cliOptions.target);
+      for (const { targetName, options: options2 } of targets) {
+        batchRunner.logForTarget(targetName, "Starting generation...");
+        await runGenerate(options2, true);
+        batchRunner.logForTarget(targetName, "Generation complete.");
+      }
+      outro3("All targets generated!");
+      return;
+    }
+    const options = configLoader.merge(cliOptions, fileConfig);
+    const silent = options.json || options.summary;
+    if (!silent) {
+      intro3("awa CLI - Template Generator");
+    }
+    await runGenerate(options, false);
+    if (!silent) {
+      outro3("Generation complete!");
+    }
   } catch (error) {
     if (error instanceof Error) {
       logger.error(error.message);
@@ -1305,49 +3172,361 @@ async function generateCommand(cliOptions) {
   }
 }
 
+// src/commands/test.ts
+import { intro as intro4, outro as outro4 } from "@clack/prompts";
+
+// src/core/template-test/fixture-loader.ts
+import { readdir as readdir3 } from "fs/promises";
+import { basename as basename2, extname, join as join9 } from "path";
+import { parse as parse2 } from "smol-toml";
+async function discoverFixtures(templatePath) {
+  const testsDir = join9(templatePath, "_tests");
+  let entries;
+  try {
+    const dirEntries = await readdir3(testsDir, { withFileTypes: true });
+    entries = dirEntries.filter((e) => e.isFile() && extname(e.name) === ".toml").map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+  const fixtures = [];
+  for (const filename of entries) {
+    const filePath = join9(testsDir, filename);
+    const fixture = await parseFixture(filePath);
+    fixtures.push(fixture);
+  }
+  return fixtures;
+}
+async function parseFixture(filePath) {
+  const content = await readTextFile(filePath);
+  const parsed = parse2(content);
+  const name = basename2(filePath, extname(filePath));
+  const features = toStringArray2(parsed.features) ?? [];
+  const preset = toStringArray2(parsed.preset) ?? [];
+  const removeFeatures = toStringArray2(parsed["remove-features"]) ?? [];
+  const expectedFiles = toStringArray2(parsed["expected-files"]) ?? [];
+  return {
+    name,
+    features,
+    preset,
+    removeFeatures,
+    expectedFiles,
+    filePath
+  };
+}
+function toStringArray2(value) {
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  return null;
+}
+
+// src/core/template-test/reporter.ts
+import chalk5 from "chalk";
+function report2(result) {
+  console.log("");
+  for (const fixture of result.results) {
+    reportFixture(fixture);
+  }
+  console.log("");
+  console.log(chalk5.bold("Test Summary:"));
+  console.log(`  Total:  ${result.total}`);
+  console.log(chalk5.green(`  Passed: ${result.passed}`));
+  if (result.failed > 0) {
+    console.log(chalk5.red(`  Failed: ${result.failed}`));
+  }
+  console.log("");
+}
+function reportFixture(fixture) {
+  const icon = fixture.passed ? chalk5.green("\u2714") : chalk5.red("\u2716");
+  console.log(`${icon} ${fixture.name}`);
+  if (fixture.error) {
+    console.log(chalk5.red(`    Error: ${fixture.error}`));
+    return;
+  }
+  const missingFiles = fixture.fileResults.filter((r) => !r.found);
+  for (const missing of missingFiles) {
+    console.log(chalk5.red(`    Missing file: ${missing.path}`));
+  }
+  const snapshotFailures = fixture.snapshotResults.filter((r) => r.status !== "match");
+  for (const failure of snapshotFailures) {
+    switch (failure.status) {
+      case "mismatch":
+        console.log(chalk5.yellow(`    Snapshot mismatch: ${failure.path}`));
+        break;
+      case "missing-snapshot":
+        console.log(chalk5.yellow(`    Missing snapshot: ${failure.path}`));
+        break;
+      case "extra-snapshot":
+        console.log(chalk5.yellow(`    Extra snapshot (not in output): ${failure.path}`));
+        break;
+    }
+  }
+}
+
+// src/core/template-test/runner.ts
+import { mkdir as mkdir3, rm as rm4 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join11 } from "path";
+
+// src/core/template-test/snapshot.ts
+import { mkdir as mkdir2, readdir as readdir4, rm as rm3 } from "fs/promises";
+import { join as join10, relative as relative4 } from "path";
+async function walkRelative(dir, base) {
+  const results = [];
+  const entries = await readdir4(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join10(dir, entry.name);
+    if (entry.isDirectory()) {
+      const sub = await walkRelative(fullPath, base);
+      results.push(...sub);
+    } else if (entry.isFile()) {
+      results.push(relative4(base, fullPath));
+    }
+  }
+  return results;
+}
+async function compareSnapshots(renderedDir, snapshotDir) {
+  const results = [];
+  const renderedFiles = await walkRelative(renderedDir, renderedDir);
+  const snapshotFiles = await walkRelative(snapshotDir, snapshotDir);
+  const snapshotSet = new Set(snapshotFiles);
+  const renderedSet = new Set(renderedFiles);
+  for (const file of renderedFiles) {
+    const renderedPath = join10(renderedDir, file);
+    const snapshotPath = join10(snapshotDir, file);
+    if (!snapshotSet.has(file)) {
+      results.push({ path: file, status: "missing-snapshot" });
+      continue;
+    }
+    const renderedContent = await readTextFile(renderedPath);
+    const snapshotContent = await readTextFile(snapshotPath);
+    results.push({
+      path: file,
+      status: renderedContent === snapshotContent ? "match" : "mismatch"
+    });
+  }
+  for (const file of snapshotFiles) {
+    if (!renderedSet.has(file)) {
+      results.push({ path: file, status: "extra-snapshot" });
+    }
+  }
+  return results;
+}
+async function updateSnapshots(renderedDir, snapshotDir) {
+  if (await pathExists(snapshotDir)) {
+    await rm3(snapshotDir, { recursive: true, force: true });
+  }
+  await mkdir2(snapshotDir, { recursive: true });
+  const files = await walkRelative(renderedDir, renderedDir);
+  for (const file of files) {
+    const srcPath = join10(renderedDir, file);
+    const destPath = join10(snapshotDir, file);
+    const content = await readTextFile(srcPath);
+    await writeTextFile(destPath, content);
+  }
+}
+
+// src/core/template-test/runner.ts
+async function runFixture(fixture, templatePath, options, presetDefinitions = {}) {
+  const tempDir = join11(tmpdir3(), `awa-test-${fixture.name}-${Date.now()}`);
+  try {
+    await mkdir3(tempDir, { recursive: true });
+    const features = featureResolver.resolve({
+      baseFeatures: [...fixture.features],
+      presetNames: [...fixture.preset],
+      removeFeatures: [...fixture.removeFeatures],
+      presetDefinitions
+    });
+    await fileGenerator.generate({
+      templatePath,
+      outputPath: tempDir,
+      features,
+      force: true,
+      dryRun: false,
+      delete: false
+    });
+    const fileResults = [];
+    for (const expectedFile of fixture.expectedFiles) {
+      const fullPath = join11(tempDir, expectedFile);
+      const found = await pathExists(fullPath);
+      fileResults.push({ path: expectedFile, found });
+    }
+    const missingFiles = fileResults.filter((r) => !r.found);
+    const snapshotDir = join11(templatePath, "_tests", fixture.name);
+    let snapshotResults = [];
+    if (options.updateSnapshots) {
+      await updateSnapshots(tempDir, snapshotDir);
+    } else if (await pathExists(snapshotDir)) {
+      snapshotResults = await compareSnapshots(tempDir, snapshotDir);
+    }
+    const snapshotFailures = snapshotResults.filter((r) => r.status !== "match");
+    const passed = missingFiles.length === 0 && snapshotFailures.length === 0;
+    return {
+      name: fixture.name,
+      passed,
+      fileResults,
+      snapshotResults
+    };
+  } catch (error) {
+    return {
+      name: fixture.name,
+      passed: false,
+      fileResults: [],
+      snapshotResults: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    await rm4(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function runAll(fixtures, templatePath, options, presetDefinitions = {}) {
+  const results = [];
+  for (const fixture of fixtures) {
+    const result = await runFixture(fixture, templatePath, options, presetDefinitions);
+    results.push(result);
+  }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  return {
+    results,
+    total: results.length,
+    passed,
+    failed
+  };
+}
+
+// src/commands/test.ts
+async function testCommand(options) {
+  try {
+    intro4("awa CLI - Template Test");
+    const fileConfig = await configLoader.load(options.config ?? null);
+    const templateSource = options.template ?? fileConfig?.template ?? null;
+    const template = await templateResolver.resolve(templateSource, false);
+    const fixtures = await discoverFixtures(template.localPath);
+    if (fixtures.length === 0) {
+      logger.warn("No test fixtures found in _tests/ directory");
+      outro4("No tests to run.");
+      return 0;
+    }
+    logger.info(`Found ${fixtures.length} fixture(s)`);
+    const presetDefinitions = fileConfig?.presets ?? {};
+    const result = await runAll(
+      fixtures,
+      template.localPath,
+      { updateSnapshots: options.updateSnapshots },
+      presetDefinitions
+    );
+    report2(result);
+    if (result.failed > 0) {
+      outro4(`${result.failed} fixture(s) failed.`);
+      return 1;
+    }
+    outro4("All tests passed!");
+    return 0;
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    return 2;
+  }
+}
+
 // src/cli/index.ts
 var version = PACKAGE_INFO.version;
 var program = new Command();
 program.name("awa").description("awa - tool for generating AI coding agent configuration files").version(version, "-v, --version", "Display version number");
-program.command("generate").description("Generate AI agent configuration files from templates").argument("[output]", "Output directory (optional if specified in config)").option("-t, --template <source>", "Template source (local path or Git repository)").option("-f, --features <flag...>", "Feature flags (can be specified multiple times)").option("--preset <name...>", "Preset names to enable (can be specified multiple times)").option(
+program.command("generate").alias("init").description("Generate AI agent configuration files from templates").argument("[output]", "Output directory (optional if specified in config)").option("-t, --template <source>", "Template source (local path or Git repository)").option("-f, --features <flag...>", "Feature flags (can be specified multiple times)").option("--preset <name...>", "Preset names to enable (can be specified multiple times)").option(
   "--remove-features <flag...>",
   "Feature flags to remove (can be specified multiple times)"
 ).option("--force", "Force overwrite existing files without prompting", false).option("--dry-run", "Preview changes without modifying files", false).option(
   "--delete",
   "Enable deletion of files listed in the delete list (default: warn only)",
   false
-).option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).action(async (output, options) => {
+).option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).option("--all", "Process all named targets from config", false).option("--target <name>", "Process a specific named target from config").option("--overlay <path...>", "Overlay directory paths applied over base template (repeatable)").option("--json", "Output results as JSON (implies --dry-run)", false).option("--summary", "Output compact one-line summary", false).action(async (output, options) => {
   const cliOptions = {
     output,
     template: options.template,
-    features: options.features || [],
-    preset: options.preset || [],
-    removeFeatures: options.removeFeatures || [],
+    features: options.features,
+    preset: options.preset,
+    removeFeatures: options.removeFeatures,
     force: options.force,
     dryRun: options.dryRun,
     delete: options.delete,
     config: options.config,
-    refresh: options.refresh
+    refresh: options.refresh,
+    all: options.all,
+    target: options.target,
+    overlay: options.overlay || [],
+    json: options.json,
+    summary: options.summary
   };
   await generateCommand(cliOptions);
 });
 program.command("diff").description("Compare template output with existing target directory").argument("[target]", "Target directory to compare against (optional if specified in config)").option("-t, --template <source>", "Template source (local path or Git repository)").option("-f, --features <flag...>", "Feature flags (can be specified multiple times)").option("--preset <name...>", "Preset names to enable (can be specified multiple times)").option(
   "--remove-features <flag...>",
   "Feature flags to remove (can be specified multiple times)"
-).option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).option("--list-unknown", "Include target-only files in diff results", false).action(async (target, options) => {
+).option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).option("--list-unknown", "Include target-only files in diff results", false).option("--all", "Process all named targets from config", false).option("--target <name>", "Process a specific named target from config").option("-w, --watch", "Watch template directory for changes and re-run diff", false).option("--overlay <path...>", "Overlay directory paths applied over base template (repeatable)").option("--json", "Output results as JSON", false).option("--summary", "Output compact one-line summary", false).action(async (target, options) => {
   const cliOptions = {
     output: target,
     // Use target as output for consistency
     template: options.template,
-    features: options.features || [],
-    preset: options.preset || [],
-    removeFeatures: options.removeFeatures || [],
+    features: options.features,
+    preset: options.preset,
+    removeFeatures: options.removeFeatures,
     config: options.config,
     refresh: options.refresh,
-    listUnknown: options.listUnknown
+    listUnknown: options.listUnknown,
+    all: options.all,
+    target: options.target,
+    watch: options.watch,
+    overlay: options.overlay || [],
+    json: options.json,
+    summary: options.summary
   };
   const exitCode = await diffCommand(cliOptions);
   process.exit(exitCode);
 });
+program.command("check").description(
+  "Validate spec files against schemas and check traceability between code markers and specs"
+).option("-c, --config <path>", "Path to configuration file").option("--ignore <pattern...>", "Glob patterns for paths to exclude").option("--format <format>", "Output format (text or json)", "text").option(
+  "--allow-warnings",
+  "Allow warnings without failing (default: warnings are errors)",
+  false
+).option(
+  "--spec-only",
+  "Run only spec-level checks (schema and cross-refs); skip code-to-spec traceability",
+  false
+).action(async (options) => {
+  const cliOptions = {
+    config: options.config,
+    ignore: options.ignore,
+    format: options.format,
+    allowWarnings: options.allowWarnings,
+    specOnly: options.specOnly
+  };
+  const exitCode = await checkCommand(cliOptions);
+  process.exit(exitCode);
+});
+program.command("features").description("Discover feature flags available in a template").option("-t, --template <source>", "Template source (local path or Git repository)").option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).option("--json", "Output results as JSON", false).action(async (options) => {
+  const exitCode = await featuresCommand({
+    template: options.template,
+    config: options.config,
+    refresh: options.refresh,
+    json: options.json
+  });
+  process.exit(exitCode);
+});
+program.command("test").description("Run template test fixtures to verify expected output").option("-t, --template <source>", "Template source (local path or Git repository)").option("-c, --config <path>", "Path to configuration file").option("--update-snapshots", "Update stored snapshots with current rendered output", false).action(async (options) => {
+  const testOptions = {
+    template: options.template,
+    config: options.config,
+    updateSnapshots: options.updateSnapshots
+  };
+  const exitCode = await testCommand(testOptions);
+  process.exit(exitCode);
+});
 program.parse();
 //# sourceMappingURL=index.js.map