@ncoderz/awa 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import {
+  ConfigError,
+  DiffError,
+  GenerationError,
+  TemplateError,
+  configLoader,
+  deleteFile,
+  ensureDir,
+  getCacheDir,
+  getTemplateDir,
+  logger,
+  pathExists,
+  readBinaryFile,
+  readTextFile,
+  rmDir,
+  walkDirectory,
+  writeTextFile
+} from "./chunk-3SSUJFKN.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -6,431 +24,1336 @@ import { Command } from "commander";
 // src/_generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@ncoderz/awa",
-  "version": "1.0.0",
+  "version": "1.2.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/config.ts
-import { parse } from "smol-toml";
-
-// src/types/index.ts
-var DiffError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DiffError";
+// 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
+      });
+    }
   }
-};
-var ConfigError = class extends Error {
-  constructor(message, code, filePath) {
-    super(message);
-    this.code = code;
-    this.filePath = filePath;
-    this.name = "ConfigError";
+  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
+        });
+      }
+    }
   }
-};
-var TemplateError = class extends Error {
-  constructor(message, code, source) {
-    super(message);
-    this.code = code;
-    this.source = source;
-    this.name = "TemplateError";
+  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
+      });
+    }
   }
-};
-var GenerationError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "GenerationError";
+  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/utils/fs.ts
-import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-async function ensureDir(dirPath) {
-  await mkdir(dirPath, { recursive: true });
+// 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.codeIgnore);
+  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");
 }
-async function pathExists(path) {
+var ID_TOKEN_RE = /^([A-Z][A-Z0-9]*(?:[-_][A-Za-z0-9]+)*(?:\.\d+)?)/;
+async function scanFile(filePath, markerNames) {
+  let content;
   try {
-    await stat(path);
-    return true;
+    content = await readFile(filePath, "utf-8");
   } catch {
-    return false;
+    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 };
 }
-async function readTextFile(path) {
-  return readFile(path, "utf-8");
-}
-async function readBinaryFile(path) {
-  return readFile(path);
+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 writeTextFile(path, content) {
-  await ensureDir(dirname(path));
-  await writeFile(path, content, "utf-8");
+async function collectCodeFiles(codeGlobs, ignore) {
+  return collectFiles(codeGlobs, ignore);
 }
-async function* walkDirectory(dir) {
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith("_")) {
-        continue;
-      }
-      yield* walkDirectory(fullPath);
-    } else if (entry.isFile()) {
-      if (entry.name.startsWith("_")) {
-        continue;
-      }
-      yield fullPath;
-    }
+
+// src/core/check/reporter.ts
+import chalk from "chalk";
+function report(findings, format) {
+  if (format === "json") {
+    reportJson(findings);
+  } else {
+    reportText(findings);
   }
 }
-function getCacheDir() {
-  return join(homedir(), ".cache", "awa", "templates");
+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 getTemplateDir() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-  if (currentDir.includes("/dist")) {
-    return join(dirname(currentDir), "templates");
+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(", ")}`);
   }
-  return join(currentDir, "..", "..", "templates");
 }
-async function rmDir(dirPath) {
-  await rm(dirPath, { recursive: true, force: true });
+function formatLocation(filePath, line) {
+  if (!filePath) return "";
+  return line ? `(${filePath}:${line})` : `(${filePath})`;
 }
-async function deleteFile(filePath) {
-  await rm(filePath, { force: true });
+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/utils/logger.ts
-import chalk from "chalk";
-var Logger = class {
-  info(message) {
-    console.log(chalk.blue("\u2139"), message);
+// 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);
+    }
   }
-  success(message) {
-    console.log(chalk.green("\u2714"), message);
+  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;
   }
-  warn(message) {
-    console.warn(chalk.yellow("\u26A0"), message);
+  const parsed = parseYaml(content);
+  if (!parsed || typeof parsed !== "object") {
+    throw new RuleValidationError(`Rule file is not a valid YAML object: ${filePath}`);
   }
-  error(message) {
-    console.error(chalk.red("\u2716"), message);
+  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}`);
   }
-  fileAction(action) {
-    const { type, outputPath } = action;
-    switch (type) {
-      case "create":
-        console.log(chalk.green("  + "), chalk.dim(outputPath));
-        break;
-      case "overwrite":
-        console.log(chalk.yellow("  ~ "), chalk.dim(outputPath));
-        break;
-      case "skip-user":
-        console.log(chalk.blue("  - "), chalk.dim(outputPath), chalk.dim("(skipped)"));
-        break;
-      case "skip-empty":
-        console.log(chalk.dim("  \xB7 "), chalk.dim(outputPath), chalk.dim("(empty)"));
-        break;
-      case "skip-equal":
-        console.log(chalk.dim("  = "), chalk.dim(outputPath), chalk.dim("(unchanged)"));
-        break;
-      case "delete":
-        console.log(chalk.red("  \u2716 "), chalk.dim(outputPath), chalk.red("(deleted)"));
-        break;
+  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)
+    );
   }
-  // @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:"));
-    if (result.created === 0 && result.overwritten === 0 && result.deleted === 0) {
-      console.log(chalk.yellow("  \u26A0 No files were created, overwritten, or deleted"));
+  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}`);
     }
-    if (result.created > 0) {
-      console.log(chalk.green(`  Created: ${result.created}`));
+    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}`);
     }
-    if (result.overwritten > 0) {
-      console.log(chalk.yellow(`  Overwritten: ${result.overwritten}`));
+    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}`);
     }
-    if (result.deleted > 0) {
-      console.log(chalk.red(`  Deleted: ${result.deleted}`));
+    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}`);
     }
-    if (result.skippedEqual > 0) {
-      console.log(chalk.dim(`  Skipped (equal): ${result.skippedEqual}`));
+    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}`);
     }
-    if (result.skippedUser > 0) {
-      console.log(chalk.blue(`  Skipped (user): ${result.skippedUser}`));
+    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})`);
     }
-    if (result.skippedEmpty > 0) {
-      console.log(chalk.dim(`  Skipped (empty): ${result.skippedEmpty}`));
+  }
+}
+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
+          )
+        );
+      }
     }
-    console.log("");
   }
-  // @awa-impl: DIFF-4_AC-3
-  diffLine(line, type) {
-    switch (type) {
-      case "add":
-        console.log(chalk.green(line));
-        break;
-      case "remove":
-        console.log(chalk.red(line));
-        break;
-      case "context":
-        console.log(chalk.dim(line));
-        break;
+  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++;
     }
   }
-  // @awa-impl: DIFF-4_AC-4, DIFF-4_AC-5
-  diffSummary(result) {
-    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`));
-    if (!result.hasDifferences) {
-      console.log(chalk.green("\u2714 No differences found"));
+  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;
     }
-    console.log(chalk.bold("Summary:"));
-    console.log(chalk.dim(`  Identical: ${result.identical}`));
-    if (result.modified > 0) {
-      console.log(chalk.yellow(`  Modified: ${result.modified}`));
+    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));
+      }
     }
-    if (result.newFiles > 0) {
-      console.log(chalk.green(`  New: ${result.newFiles}`));
+  }
+  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)}$`);
     }
-    if (result.extraFiles > 0) {
-      console.log(chalk.red(`  Extra: ${result.extraFiles}`));
+  }
+  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
+        }
+      ];
     }
-    if (result.binaryDiffers > 0) {
-      console.log(chalk.red(`  Binary differs: ${result.binaryDiffers}`));
+    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 (result.deleteListed > 0) {
-      console.log(chalk.red(`  Delete listed: ${result.deleteListed}`));
+    if (!firstMismatch) {
+      firstMismatch = { table, headers };
     }
-    console.log("");
   }
-};
-var logger = new Logger();
-
-// src/core/config.ts
-var DEFAULT_CONFIG_PATH = ".awa.toml";
-var ConfigLoader = class {
-  // @awa-impl: CFG-1_AC-1, CFG-1_AC-2, CFG-1_AC-3, CFG-1_AC-4
-  async load(configPath) {
-    const pathToLoad = configPath ?? DEFAULT_CONFIG_PATH;
-    const exists = await pathExists(pathToLoad);
-    if (configPath && !exists) {
-      throw new ConfigError(
-        `Configuration file not found: ${configPath}`,
-        "FILE_NOT_FOUND",
-        configPath
-      );
-    }
-    if (!configPath && !exists) {
-      return null;
+  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
     }
-    try {
-      const content = await readTextFile(pathToLoad);
-      const parsed = parse(content);
-      const config = {};
-      if (parsed.output !== void 0) {
-        if (typeof parsed.output !== "string") {
-          throw new ConfigError(
-            `Invalid type for 'output': expected string, got ${typeof parsed.output}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config.output = parsed.output;
+  ];
+}
+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
       }
-      if (parsed.template !== void 0) {
-        if (typeof parsed.template !== "string") {
-          throw new ConfigError(
-            `Invalid type for 'template': expected string, got ${typeof parsed.template}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config.template = parsed.template;
+    ];
+  }
+  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 (parsed.features !== void 0) {
-        if (!Array.isArray(parsed.features) || !parsed.features.every((f) => typeof f === "string")) {
-          throw new ConfigError(
-            `Invalid type for 'features': expected array of strings`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config.features = parsed.features;
+      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;
       }
-      if (parsed.preset !== void 0) {
-        if (!Array.isArray(parsed.preset) || !parsed.preset.every((p) => typeof p === "string")) {
-          throw new ConfigError(
-            `Invalid type for 'preset': expected array of strings`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
+    }
+  }
+  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);
         }
-        config.preset = parsed.preset;
       }
-      if (parsed["remove-features"] !== void 0) {
-        if (!Array.isArray(parsed["remove-features"]) || !parsed["remove-features"].every((f) => typeof f === "string")) {
-          throw new ConfigError(
-            `Invalid type for 'remove-features': expected array of strings`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config["remove-features"] = parsed["remove-features"];
+    }
+  }
+  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.specIgnore);
+  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);
       }
-      if (parsed.force !== void 0) {
-        if (typeof parsed.force !== "boolean") {
-          throw new ConfigError(
-            `Invalid type for 'force': expected boolean, got ${typeof parsed.force}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config.force = parsed.force;
+    }
+  }
+  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 });
       }
-      if (parsed["dry-run"] !== void 0) {
-        if (typeof parsed["dry-run"] !== "boolean") {
-          throw new ConfigError(
-            `Invalid type for 'dry-run': expected boolean, got ${typeof parsed["dry-run"]}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
+    }
+    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 });
         }
-        config["dry-run"] = parsed["dry-run"];
       }
-      if (parsed.delete !== void 0) {
-        if (typeof parsed.delete !== "boolean") {
-          throw new ConfigError(
-            `Invalid type for 'delete': expected boolean, got ${typeof parsed.delete}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
+    }
+  }
+  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
+          });
         }
-        config.delete = parsed.delete;
       }
-      if (parsed.refresh !== void 0) {
-        if (typeof parsed.refresh !== "boolean") {
-          throw new ConfigError(
-            `Invalid type for 'refresh': expected boolean, got ${typeof parsed.refresh}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config.refresh = parsed.refresh;
+    }
+  }
+  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]);
       }
-      if (parsed.presets !== void 0) {
-        if (parsed.presets === null || typeof parsed.presets !== "object" || Array.isArray(parsed.presets)) {
-          throw new ConfigError(
-            `Invalid type for 'presets': expected table of string arrays`,
-            "INVALID_PRESET",
-            pathToLoad
-          );
-        }
-        const defs = {};
-        for (const [presetName, value] of Object.entries(
-          parsed.presets
-        )) {
-          if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
-            throw new ConfigError(
-              `Invalid preset '${presetName}': expected array of strings`,
-              "INVALID_PRESET",
-              pathToLoad
-            );
+    }
+    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]);
           }
-          defs[presetName] = value;
-        }
-        config.presets = defs;
-      }
-      if (parsed["list-unknown"] !== void 0) {
-        if (typeof parsed["list-unknown"] !== "boolean") {
-          throw new ConfigError(
-            `Invalid type for 'list-unknown': expected boolean, got ${typeof parsed["list-unknown"]}`,
-            "INVALID_TYPE",
-            pathToLoad
-          );
-        }
-        config["list-unknown"] = parsed["list-unknown"];
-      }
-      const knownKeys = /* @__PURE__ */ new Set([
-        "output",
-        "template",
-        "features",
-        "preset",
-        "remove-features",
-        "presets",
-        "force",
-        "dry-run",
-        "delete",
-        "refresh",
-        "list-unknown"
-      ]);
-      for (const key of Object.keys(parsed)) {
-        if (!knownKeys.has(key)) {
-          logger.warn(`Unknown configuration option: '${key}'`);
         }
       }
-      return config;
-    } catch (error) {
-      if (error instanceof ConfigError) {
-        throw error;
+    }
+    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/ARCHITECTURE.md",
+    ".awa/specs/FEAT-*.md",
+    ".awa/specs/REQ-*.md",
+    ".awa/specs/DESIGN-*.md",
+    ".awa/specs/EXAMPLES-*.md",
+    ".awa/specs/API-*.tsp",
+    ".awa/tasks/TASK-*.md",
+    ".awa/plans/PLAN-*.md",
+    ".awa/align/ALIGN-*.md"
+  ],
+  codeGlobs: [
+    "**/*.{ts,js,tsx,jsx,mts,mjs,cjs,py,go,rs,java,kt,kts,cs,c,h,cpp,cc,cxx,hpp,hxx,swift,rb,php,scala,ex,exs,dart,lua,zig}"
+  ],
+  specIgnore: [],
+  codeIgnore: [
+    "node_modules/**",
+    "dist/**",
+    "vendor/**",
+    "target/**",
+    "build/**",
+    "out/**",
+    ".awa/**"
+  ],
+  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/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 configSpecIgnore = toStringArray(section?.["spec-ignore"]) ?? [
+    ...DEFAULT_CHECK_CONFIG.specIgnore
+  ];
+  const configCodeIgnore = toStringArray(section?.["code-ignore"]) ?? [
+    ...DEFAULT_CHECK_CONFIG.codeIgnore
+  ];
+  const specIgnore = [...configSpecIgnore, ...cliOptions.specIgnore ?? []];
+  const codeIgnore = [...configCodeIgnore, ...cliOptions.codeIgnore ?? []];
+  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,
+    specIgnore,
+    codeIgnore,
+    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(
-        `Failed to parse TOML configuration: ${error instanceof Error ? error.message : String(error)}`,
-        "PARSE_ERROR",
-        pathToLoad
+        "No configuration file found. --all and --target require a config file with [targets.*] sections.",
+        "NO_TARGETS",
+        null
       );
     }
-  }
-  // @awa-impl: CFG-4_AC-1, CFG-4_AC-2, CFG-4_AC-3, CFG-4_AC-4
-  // @awa-impl: CLI-2_AC-2, CLI-2_AC-3, CLI-2_AC-4
-  merge(cli, file) {
-    const output = cli.output ?? file?.output;
-    if (!output) {
+    const targetNames = configLoader.getTargetNames(fileConfig);
+    if (targetNames.length === 0) {
       throw new ConfigError(
-        "Output directory is required. Provide it as a positional argument or in the config file.",
-        "MISSING_OUTPUT",
+        "No targets defined in configuration. Add [targets.<name>] sections to .awa.toml.",
+        "NO_TARGETS",
         null
       );
     }
-    const template = cli.template ?? file?.template ?? null;
-    const features = cli.features ?? file?.features ?? [];
-    const preset = cli.preset ?? file?.preset ?? [];
-    const removeFeatures = cli.removeFeatures ?? file?.["remove-features"] ?? [];
-    const presets = file?.presets ?? {};
-    const force = cli.force ?? file?.force ?? false;
-    const dryRun = cli.dryRun ?? file?.["dry-run"] ?? false;
-    const enableDelete = cli.delete ?? file?.delete ?? false;
-    const refresh = cli.refresh ?? file?.refresh ?? false;
-    const listUnknown = cli.listUnknown ?? file?.["list-unknown"] ?? false;
-    return {
-      output,
-      template,
-      features,
-      preset,
-      removeFeatures,
-      force,
-      dryRun,
-      delete: enableDelete,
-      refresh,
-      presets,
-      listUnknown
-    };
+    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";
@@ -661,7 +1584,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 +1627,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",
@@ -1073,9 +2000,62 @@ 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 join6 } from "path";
+
 // src/core/template-resolver.ts
 import { createHash } from "crypto";
-import { rm as rm2 } from "fs/promises";
+import { rm } from "fs/promises";
 import { isAbsolute, join as join5, resolve } from "path";
 import degit from "degit";
 var TemplateResolver = class {
@@ -1119,7 +2099,7 @@ var TemplateResolver = class {
       try {
         if (cacheExists && refresh) {
           logger.info(`Refreshing template: ${source}`);
-          await rm2(cachePath, { recursive: true, force: true });
+          await rm(cachePath, { recursive: true, force: true });
         } else {
           logger.info(`Fetching template: ${source}`);
         }
@@ -1145,7 +2125,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";
@@ -1155,38 +2135,99 @@ var TemplateResolver = class {
     }
     return "git";
   }
-  // @awa-impl: TPL-3_AC-1
-  getCachePath(source) {
-    const hash = createHash("sha256").update(source).digest("hex").substring(0, 16);
-    const cacheDir = getCacheDir();
-    return join5(cacheDir, hash);
+  // @awa-impl: TPL-3_AC-1
+  getCachePath(source) {
+    const hash = createHash("sha256").update(source).digest("hex").substring(0, 16);
+    const cacheDir = getCacheDir();
+    return join5(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 = join6(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;
+    }
   }
 };
-var templateResolver = new TemplateResolver();
 
 // 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 +2266,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 +2376,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 chalk3 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(chalk3.yellow("No feature flags found."));
+      console.log(chalk3.dim(`(${filesScanned} files scanned)`));
+      return;
+    }
+    console.log(chalk3.bold(`Feature flags (${features.length} found):
+`));
+    for (const feature of features) {
+      console.log(`  ${chalk3.cyan(feature.name)}`);
+      for (const file of feature.files) {
+        console.log(`    ${chalk3.dim(file)}`);
+      }
+    }
+    console.log("");
+    console.log(chalk3.dim(`${filesScanned} files scanned`));
+    if (presets && Object.keys(presets).length > 0) {
+      console.log("");
+      console.log(chalk3.bold("Presets (from .awa.toml):\n"));
+      for (const [name, flags] of Object.entries(presets)) {
+        console.log(`  ${chalk3.green(name)}: ${flags.join(", ")}`);
+      }
+    }
+  }
+};
+var featuresReporter = new FeaturesReporter();
+
+// src/core/features/scanner.ts
+import { readdir, readFile as readFile5 } from "fs/promises";
+import { join as join7, relative as relative3 } from "path";
+var FEATURE_PATTERN = /it\.features\.(?:includes|indexOf)\(\s*['"]([^'"]+)['"]\s*\)/g;
+async function* walkAllFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join7(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 readFile5(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 +2546,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 +2569,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 +2647,483 @@ 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 readdir2 } from "fs/promises";
+import { basename as basename2, extname, join as join8 } from "path";
+import { parse } from "smol-toml";
+async function discoverFixtures(templatePath) {
+  const testsDir = join8(templatePath, "_tests");
+  let entries;
+  try {
+    const dirEntries = await readdir2(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 = join8(testsDir, filename);
+    const fixture = await parseFixture(filePath);
+    fixtures.push(fixture);
+  }
+  return fixtures;
+}
+async function parseFixture(filePath) {
+  const content = await readTextFile(filePath);
+  const parsed = parse(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 chalk4 from "chalk";
+function report2(result) {
+  console.log("");
+  for (const fixture of result.results) {
+    reportFixture(fixture);
+  }
+  console.log("");
+  console.log(chalk4.bold("Test Summary:"));
+  console.log(`  Total:  ${result.total}`);
+  console.log(chalk4.green(`  Passed: ${result.passed}`));
+  if (result.failed > 0) {
+    console.log(chalk4.red(`  Failed: ${result.failed}`));
+  }
+  console.log("");
+}
+function reportFixture(fixture) {
+  const icon = fixture.passed ? chalk4.green("\u2714") : chalk4.red("\u2716");
+  console.log(`${icon} ${fixture.name}`);
+  if (fixture.error) {
+    console.log(chalk4.red(`    Error: ${fixture.error}`));
+    return;
+  }
+  const missingFiles = fixture.fileResults.filter((r) => !r.found);
+  for (const missing of missingFiles) {
+    console.log(chalk4.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(chalk4.yellow(`    Snapshot mismatch: ${failure.path}`));
+        break;
+      case "missing-snapshot":
+        console.log(chalk4.yellow(`    Missing snapshot: ${failure.path}`));
+        break;
+      case "extra-snapshot":
+        console.log(chalk4.yellow(`    Extra snapshot (not in output): ${failure.path}`));
+        break;
+    }
+  }
+}
+
+// src/core/template-test/runner.ts
+import { mkdir as mkdir2, rm as rm3 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join10 } from "path";
+
+// src/core/template-test/snapshot.ts
+import { mkdir, readdir as readdir3, rm as rm2 } from "fs/promises";
+import { join as join9, relative as relative4 } from "path";
+async function walkRelative(dir, base) {
+  const results = [];
+  const entries = await readdir3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join9(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 = join9(renderedDir, file);
+    const snapshotPath = join9(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 rm2(snapshotDir, { recursive: true, force: true });
+  }
+  await mkdir(snapshotDir, { recursive: true });
+  const files = await walkRelative(renderedDir, renderedDir);
+  for (const file of files) {
+    const srcPath = join9(renderedDir, file);
+    const destPath = join9(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 = join10(tmpdir3(), `awa-test-${fixture.name}-${Date.now()}`);
+  try {
+    await mkdir2(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 = join10(tempDir, expectedFile);
+      const found = await pathExists(fullPath);
+      fileResults.push({ path: expectedFile, found });
+    }
+    const missingFiles = fileResults.filter((r) => !r.found);
+    const snapshotDir = join10(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 rm3(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/utils/update-check.ts
+import chalk5 from "chalk";
+function compareSemver(a, b) {
+  const partsA = a.split(".").map((s) => Number.parseInt(s, 10));
+  const partsB = b.split(".").map((s) => Number.parseInt(s, 10));
+  for (let i = 0; i < 3; i++) {
+    const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function isMajorVersionBump(current, latest) {
+  const currentMajor = Number.parseInt(current.split(".")[0] ?? "0", 10);
+  const latestMajor = Number.parseInt(latest.split(".")[0] ?? "0", 10);
+  return latestMajor > currentMajor;
+}
+async function checkForUpdate() {
+  try {
+    const response = await fetch("https://registry.npmjs.org/@ncoderz/awa/latest", {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const latest = data.version;
+    if (!latest || typeof latest !== "string") return null;
+    const current = PACKAGE_INFO.version;
+    const isOutdated = compareSemver(current, latest) < 0;
+    return {
+      current,
+      latest,
+      isOutdated,
+      isMajorBump: isOutdated && isMajorVersionBump(current, latest)
+    };
+  } catch {
+    return null;
+  }
+}
+function printUpdateWarning(log, result) {
+  if (!result.isOutdated) return;
+  console.log("");
+  if (result.isMajorBump) {
+    log.warn(
+      chalk5.yellow(
+        `New major version available: ${result.current} \u2192 ${result.latest} (breaking changes)`
+      )
+    );
+    log.warn(chalk5.dim("  See https://github.com/ncoderz/awa/releases for details"));
+  } else {
+    log.warn(chalk5.yellow(`Update available: ${result.current} \u2192 ${result.latest}`));
+  }
+  log.warn(chalk5.dim("  Run `npm install -g @ncoderz/awa` to update"));
+  console.log("");
+}
+
+// src/utils/update-check-cache.ts
+import { mkdir as mkdir3, readFile as readFile6, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join as join11 } from "path";
+var CACHE_DIR = join11(homedir(), ".cache", "awa");
+var CACHE_FILE = join11(CACHE_DIR, "update-check.json");
+var DEFAULT_INTERVAL_MS = 864e5;
+async function shouldCheck(intervalMs = DEFAULT_INTERVAL_MS) {
+  try {
+    const raw = await readFile6(CACHE_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data.timestamp !== "number" || typeof data.latestVersion !== "string") {
+      return true;
+    }
+    return Date.now() - data.timestamp >= intervalMs;
+  } catch {
+    return true;
+  }
+}
+async function writeCache(latestVersion) {
+  try {
+    await mkdir3(dirname(CACHE_FILE), { recursive: true });
+    const data = {
+      timestamp: Date.now(),
+      latestVersion
+    };
+    await writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
+  } catch {
+  }
+}
+
 // 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.parse();
+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("--spec-ignore <pattern...>", "Glob patterns to exclude from spec file scanning").option("--code-ignore <pattern...>", "Glob patterns to exclude from code file scanning").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,
+    specIgnore: options.specIgnore,
+    codeIgnore: options.codeIgnore,
+    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);
+});
+var updateCheckPromise = null;
+var isJsonOrSummary = process.argv.includes("--json") || process.argv.includes("--summary");
+var isTTY = process.stdout.isTTY === true;
+var isDisabledByEnv = !!process.env.NO_UPDATE_NOTIFIER;
+if (!isJsonOrSummary && isTTY && !isDisabledByEnv) {
+  updateCheckPromise = (async () => {
+    try {
+      const { configLoader: configLoader2 } = await import("./config-2TOQATI3.js");
+      const configPath = process.argv.indexOf("-c") !== -1 ? process.argv[process.argv.indexOf("-c") + 1] : process.argv.indexOf("--config") !== -1 ? process.argv[process.argv.indexOf("--config") + 1] : void 0;
+      const fileConfig = await configLoader2.load(configPath ?? null);
+      const updateCheckConfig = fileConfig?.["update-check"];
+      if (updateCheckConfig?.enabled === false) return null;
+      const intervalSeconds = updateCheckConfig?.interval ?? 86400;
+      const intervalMs = intervalSeconds * 1e3;
+      const needsCheck = await shouldCheck(intervalMs);
+      if (!needsCheck) return null;
+      const result = await checkForUpdate();
+      if (result) {
+        await writeCache(result.latest);
+      }
+      return result;
+    } catch {
+      return null;
+    }
+  })();
+}
+program.hook("postAction", async () => {
+  if (!updateCheckPromise) return;
+  try {
+    const result = await updateCheckPromise;
+    if (result?.isOutdated) {
+      printUpdateWarning(logger, result);
+    }
+  } catch {
+  }
+});
+program.parseAsync();
 //# sourceMappingURL=index.js.map