@ncoderz/awa 1.7.2 → 1.8.0

package/dist/index.js

@@ -1,4 +1,14 @@
 #!/usr/bin/env node
+import {
+  DEFAULT_CHECK_CONFIG,
+  collectFiles,
+  matchSimpleGlob,
+  parseSpecs,
+  propagate,
+  renumberCommand,
+  scan,
+  scanMarkers
+} from "./chunk-WGGMDWBE.js";
 import {
   ConfigError,
   DiffError,
@@ -16,7 +26,7 @@ import {
   rmDir,
   walkDirectory,
   writeTextFile
-} from "./chunk-OQZTQ5ZI.js";
+} from "./chunk-LRQWZCYL.js";
 
 // src/cli/index.ts
 import { Command, Option } from "commander";
@@ -24,9 +34,9 @@ import { Command, Option } from "commander";
 // src/_generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@ncoderz/awa",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "author": "Richard Sewell <richard.sewell@ncoderz.com>",
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "description": "awa is an Agent Workflow for AIs. It is also a CLI tool to powerfully manage agent workflow files using templates."
 };
 
@@ -201,154 +211,331 @@ function checkCodeAgainstSpec(markers, specs, config) {
   return { findings };
 }
 
-// src/core/check/marker-scanner.ts
-import { readFile } from "fs/promises";
+// src/core/check/codes-fixer.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { basename as basename2 } from "path";
 
-// 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);
+// src/core/codes/scanner.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+async function scanCodes(specFiles, specGlobs, specIgnore) {
+  const codeMap = /* @__PURE__ */ new Map();
+  const featFiles = await collectFiles(
+    specGlobs.filter((g) => g.includes("FEAT-")),
+    specIgnore
+  );
+  for (const fp of featFiles) {
+    const fileName = basename(fp);
+    const match = /^FEAT-([A-Z][A-Z0-9]*)-(.+)\.md$/.exec(fileName);
+    if (!match?.[1]) continue;
+    const code = match[1];
+    const existing = codeMap.get(code);
+    if (existing) {
+      existing.feat = true;
+    } else {
+      codeMap.set(code, {
+        feature: match[2] ?? code,
+        reqCount: 0,
+        feat: true,
+        req: false,
+        design: false,
+        api: false,
+        example: false
+      });
+    }
+  }
+  for (const sf of specFiles) {
+    if (!sf.code) continue;
+    const fileName = basename(sf.filePath);
+    const prefix = fileName.split("-")[0];
+    const existing = codeMap.get(sf.code);
+    if (existing) {
+      if (prefix === "REQ") {
+        existing.req = true;
+        existing.reqCount += sf.requirementIds.length;
+        if (existing.feature === sf.code || !existing.feature) {
+          existing.feature = extractFeatureName(fileName);
+        }
+      } else if (prefix === "DESIGN") {
+        existing.design = true;
+      } else if (prefix === "API") {
+        existing.api = true;
+      } else if (prefix === "EXAMPLE") {
+        existing.example = true;
+      } else if (prefix === "FEAT") {
+        existing.feat = true;
       }
+    } else {
+      const feature = prefix === "REQ" ? extractFeatureName(fileName) : extractFeatureNameGeneric(fileName);
+      codeMap.set(sf.code, {
+        feature,
+        reqCount: prefix === "REQ" ? sf.requirementIds.length : 0,
+        feat: prefix === "FEAT",
+        req: prefix === "REQ",
+        design: prefix === "DESIGN",
+        api: prefix === "API",
+        example: prefix === "EXAMPLE"
+      });
     }
   }
-  return [...new Set(files)];
-}
-
-// src/core/check/marker-scanner.ts
-var MARKER_TYPE_MAP = {
-  "@awa-impl": "impl",
-  "@awa-test": "test",
-  "@awa-component": "component"
-};
-var IGNORE_FILE_RE = new RegExp("@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 scopeMap = await extractScopeSummaries(specFiles, specGlobs, specIgnore);
+  const codes = [];
+  for (const [code, meta] of codeMap) {
+    const docs = {
+      feat: meta.feat,
+      req: meta.req,
+      design: meta.design,
+      api: meta.api,
+      example: meta.example
+    };
+    codes.push({
+      code,
+      feature: meta.feature,
+      reqCount: meta.reqCount,
+      scope: scopeMap.get(code) ?? "",
+      docs
+    });
+  }
+  codes.sort((a, b) => a.code.localeCompare(b.code));
+  return { codes };
+}
+function extractFeatureName(fileName) {
+  const name = basename(fileName, ".md");
+  const match = /^REQ-[A-Z][A-Z0-9]*-(.+)$/.exec(name);
+  return match?.[1] ?? name;
+}
+function extractFeatureNameGeneric(fileName) {
+  const name = basename(fileName).replace(/\.[^.]+$/, "");
+  const match = /^[A-Z]+-[A-Z][A-Z0-9]*-(.+)$/.exec(name);
+  return match?.[1] ?? name;
+}
+async function extractScopeSummaries(specFiles, specGlobs, specIgnore) {
+  const scopeMap = /* @__PURE__ */ new Map();
+  const featByCode = buildFileRefMapFromSpecFiles(specFiles, "FEAT");
+  const reqByCode = buildFileRefMapFromSpecFiles(specFiles, "REQ");
+  const designByCode = buildFileRefMapFromSpecFiles(specFiles, "DESIGN");
+  const scopeFeatFiles = await collectFiles(
+    specGlobs.filter((g) => g.includes("FEAT-")),
+    specIgnore
+  );
+  for (const fp of scopeFeatFiles) {
+    const name = basename(fp, ".md");
+    const match = /^FEAT-([A-Z][A-Z0-9]*)-/.exec(name);
+    if (match?.[1] && !featByCode.has(match[1])) {
+      featByCode.set(match[1], { filePath: fp });
     }
-    const result = await scanFile(filePath, config.markers);
-    markers.push(...result.markers);
-    findings.push(...result.findings);
   }
-  return { markers, findings };
+  const allCodes = /* @__PURE__ */ new Set();
+  for (const code of featByCode.keys()) allCodes.add(code);
+  for (const sf of specFiles) {
+    if (sf.code) {
+      allCodes.add(sf.code);
+    }
+  }
+  for (const code of allCodes) {
+    const scope = await resolveScope(code, featByCode, reqByCode, designByCode);
+    if (scope) {
+      scopeMap.set(code, scope);
+    }
+  }
+  return scopeMap;
 }
-function buildMarkerRegex(markerNames) {
-  const escaped = markerNames.map((m) => m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  return new RegExp(`(${escaped.join("|")}):\\s*(.+)`, "g");
+async function resolveScope(code, featByCode, reqByCode, designByCode) {
+  const featRef = featByCode.get(code);
+  if (featRef) {
+    const content = await readContent(featRef);
+    if (content) {
+      const scopeBoundary = extractScopeBoundary(content);
+      if (scopeBoundary) return scopeBoundary;
+      const firstParagraph = extractFirstParagraph(content);
+      if (firstParagraph) return firstParagraph;
+    }
+  }
+  const reqRef = reqByCode.get(code);
+  if (reqRef) {
+    const content = await readContent(reqRef);
+    if (content) {
+      const firstParagraph = extractFirstParagraph(content);
+      if (firstParagraph) return firstParagraph;
+    }
+  }
+  const designRef = designByCode.get(code);
+  if (designRef) {
+    const content = await readContent(designRef);
+    if (content) {
+      const firstParagraph = extractFirstParagraph(content);
+      if (firstParagraph) return firstParagraph;
+    }
+  }
+  return "";
 }
-var ID_TOKEN_RE = /^([A-Z][A-Z0-9]*(?:[-_][A-Za-z0-9]+)*(?:\.\d+)?(?:[-_][A-Za-z0-9]+)*)/;
-async function scanFile(filePath, markerNames) {
-  let content;
+async function readContent(ref) {
+  if (ref.content != null) return ref.content;
   try {
-    content = await readFile(filePath, "utf-8");
+    return await readFile(ref.filePath, "utf-8");
   } catch {
-    return { markers: [], findings: [] };
+    return void 0;
   }
-  if (IGNORE_FILE_RE.test(content)) {
-    return { markers: [], findings: [] };
+}
+function buildFileRefMapFromSpecFiles(specFiles, prefix) {
+  const map = /* @__PURE__ */ new Map();
+  for (const sf of specFiles) {
+    if (sf.code && basename(sf.filePath).startsWith(`${prefix}-`) && !map.has(sf.code)) {
+      map.set(sf.code, { filePath: sf.filePath, content: sf.content });
+    }
   }
-  const regex = buildMarkerRegex(markerNames);
+  return map;
+}
+function extractScopeBoundary(content) {
   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;
+  let inSection = false;
+  const paragraphLines = [];
+  for (const line of lines) {
+    if (!inSection) {
+      if (/^##\s+Scope Boundary\s*$/.test(line)) {
+        inSection = true;
+      }
       continue;
     }
-    if (ignoreBlock) {
+    const trimmed = line.trim();
+    if (paragraphLines.length === 0 && trimmed === "") {
       continue;
     }
-    if (ignoreNextLine) {
-      ignoreNextLine = false;
-      continue;
+    if (paragraphLines.length > 0 && (trimmed === "" || /^#/.test(trimmed))) {
+      break;
     }
-    if (IGNORE_NEXT_LINE_RE.test(line)) {
-      ignoreNextLine = true;
+    paragraphLines.push(trimmed);
+  }
+  const paragraph = paragraphLines.join(" ").trim();
+  if (paragraph.length > 120) {
+    return `${paragraph.slice(0, 117)}...`;
+  }
+  return paragraph;
+}
+function extractFirstParagraph(content) {
+  const lines = content.split("\n");
+  let foundHeading = false;
+  const paragraphLines = [];
+  for (const line of lines) {
+    if (!foundHeading) {
+      if (/^##\s/.test(line)) {
+        foundHeading = true;
+      }
       continue;
     }
-    if (IGNORE_LINE_RE.test(line)) {
+    const trimmed = line.trim();
+    if (paragraphLines.length === 0 && trimmed === "") {
       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);
+    if (paragraphLines.length > 0 && (trimmed === "" || /^#/.test(trimmed))) {
+      break;
     }
+    paragraphLines.push(trimmed);
   }
-  return { markers, findings };
+  const paragraph = paragraphLines.join(" ").trim();
+  if (paragraph.length > 120) {
+    return `${paragraph.slice(0, 117)}...`;
+  }
+  return paragraph;
 }
-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";
+
+// src/core/check/codes-fixer.ts
+function sanitizeCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/[\r\n]+/g, " ").trim();
 }
-async function collectCodeFiles(codeGlobs, ignore) {
-  return collectFiles(codeGlobs, ignore);
+async function fixCodesTable(specs, config) {
+  const archFile = specs.specFiles.find((sf) => basename2(sf.filePath) === "ARCHITECTURE.md");
+  if (!archFile) {
+    return { filesFixed: 0, fileResults: [], emptyScopeCodes: [] };
+  }
+  let content;
+  if (archFile.content != null) {
+    content = archFile.content;
+  } else {
+    try {
+      content = await readFile2(archFile.filePath, "utf-8");
+    } catch {
+      return { filesFixed: 0, fileResults: [], emptyScopeCodes: [] };
+    }
+  }
+  const lines = content.split("\n");
+  const sectionStart = lines.findIndex((l) => /^##\s+Feature Codes\s*$/.test(l));
+  if (sectionStart === -1) {
+    return { filesFixed: 0, fileResults: [], emptyScopeCodes: [] };
+  }
+  const codesResult = await scanCodes(specs.specFiles, config.specGlobs, config.specIgnore);
+  const tableLines = [];
+  tableLines.push("");
+  tableLines.push(
+    "Run `awa spec codes` for the live inventory. The table below defines scope boundaries."
+  );
+  tableLines.push("");
+  tableLines.push("| Code | Feature | Scope Boundary |");
+  tableLines.push("|------|---------|----------------|");
+  const emptyScopeCodes = [];
+  for (const code of codesResult.codes) {
+    const scope = sanitizeCell(code.scope || "");
+    if (!scope) {
+      emptyScopeCodes.push(code.code);
+    }
+    tableLines.push(`| ${sanitizeCell(code.code)} | ${sanitizeCell(code.feature)} | ${scope} |`);
+  }
+  const newSection = tableLines.join("\n");
+  const newContent = replaceFeatureCodesSection(content, sectionStart, newSection);
+  if (newContent === content) {
+    return {
+      filesFixed: 0,
+      fileResults: [{ filePath: archFile.filePath, changed: false }],
+      emptyScopeCodes
+    };
+  }
+  await writeFile(archFile.filePath, newContent, "utf-8");
+  return {
+    filesFixed: 1,
+    fileResults: [{ filePath: archFile.filePath, changed: true }],
+    emptyScopeCodes
+  };
+}
+function replaceFeatureCodesSection(content, sectionStart, newSection) {
+  const lines = content.split("\n");
+  let sectionEnd = lines.length;
+  for (let i = sectionStart + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && /^##\s/.test(line)) {
+      sectionEnd = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, sectionStart + 1);
+  const after = lines.slice(sectionEnd);
+  const result = [...before, newSection.trimEnd(), "", ...after];
+  return result.join("\n");
 }
 
 // src/core/check/matrix-fixer.ts
-import { readFile as readFile2, writeFile } from "fs/promises";
-import { basename } from "path";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename3 } from "path";
 async function fixMatrices(specs, crossRefPatterns) {
   const reqFileMaps = buildReqFileMaps(specs.specFiles);
   const fileResults = [];
   for (const specFile of specs.specFiles) {
-    const fileName = basename(specFile.filePath);
+    const fileName = basename3(specFile.filePath);
     if (fileName.startsWith("DESIGN-")) {
-      const changed = await fixDesignMatrix(specFile.filePath, reqFileMaps, crossRefPatterns);
+      const changed = await fixDesignMatrix(
+        specFile.filePath,
+        reqFileMaps,
+        crossRefPatterns,
+        specFile.content
+      );
       fileResults.push({ filePath: specFile.filePath, changed });
     } else if (fileName.startsWith("TASK-")) {
-      const changed = await fixTaskMatrix(specFile.filePath, reqFileMaps, specs, crossRefPatterns);
+      const changed = await fixTaskMatrix(
+        specFile.filePath,
+        reqFileMaps,
+        specs,
+        crossRefPatterns,
+        specFile.content
+      );
       fileResults.push({ filePath: specFile.filePath, changed });
     }
   }
@@ -361,7 +548,7 @@ function buildReqFileMaps(specFiles) {
   const idToReqFile = /* @__PURE__ */ new Map();
   const codeToReqFilesSet = /* @__PURE__ */ new Map();
   for (const sf of specFiles) {
-    const fileName = basename(sf.filePath);
+    const fileName = basename3(sf.filePath);
     if (!/\bREQ-/.test(fileName)) continue;
     for (const reqId of sf.requirementIds) {
       idToReqFile.set(reqId, fileName);
@@ -395,12 +582,16 @@ function resolveReqFile(id, maps) {
   }
   return void 0;
 }
-async function fixDesignMatrix(filePath, reqFileMaps, crossRefPatterns) {
+async function fixDesignMatrix(filePath, reqFileMaps, crossRefPatterns, cachedContent) {
   let content;
-  try {
-    content = await readFile2(filePath, "utf-8");
-  } catch {
-    return false;
+  if (cachedContent != null) {
+    content = cachedContent;
+  } else {
+    try {
+      content = await readFile3(filePath, "utf-8");
+    } catch {
+      return false;
+    }
   }
   const { components, properties } = parseDesignFileData(content, crossRefPatterns);
   const acToComponents = /* @__PURE__ */ new Map();
@@ -424,7 +615,7 @@ async function fixDesignMatrix(filePath, reqFileMaps, crossRefPatterns) {
   const newSection = generateDesignSection(grouped, acToComponents, acToProperties);
   const newContent = replaceTraceabilitySection(content, newSection);
   if (newContent === content) return false;
-  await writeFile(filePath, newContent, "utf-8");
+  await writeFile2(filePath, newContent, "utf-8");
   return true;
 }
 function parseDesignFileData(content, crossRefPatterns) {
@@ -495,12 +686,16 @@ function generateDesignSection(grouped, acToComponents, acToProperties) {
   }
   return lines.join("\n");
 }
-async function fixTaskMatrix(filePath, reqFileMaps, specs, crossRefPatterns) {
+async function fixTaskMatrix(filePath, reqFileMaps, specs, crossRefPatterns, cachedContent) {
   let content;
-  try {
-    content = await readFile2(filePath, "utf-8");
-  } catch {
-    return false;
+  if (cachedContent != null) {
+    content = cachedContent;
+  } else {
+    try {
+      content = await readFile3(filePath, "utf-8");
+    } catch {
+      return false;
+    }
   }
   const { tasks, sourceDesigns } = parseTaskFileData(content, crossRefPatterns);
   const acToTasks = /* @__PURE__ */ new Map();
@@ -523,7 +718,7 @@ async function fixTaskMatrix(filePath, reqFileMaps, specs, crossRefPatterns) {
   for (const designName of sourceDesigns) {
     const designCode = extractCodeFromFileName(designName);
     for (const sf of specs.specFiles) {
-      if (sf.code === designCode && /\bDESIGN-/.test(basename(sf.filePath))) {
+      if (sf.code === designCode && /\bDESIGN-/.test(basename3(sf.filePath))) {
         for (const propId of sf.propertyIds) sourcePropertyIds.add(propId);
       }
     }
@@ -533,7 +728,7 @@ async function fixTaskMatrix(filePath, reqFileMaps, specs, crossRefPatterns) {
   const newSection = generateTaskSection(grouped, acToTasks, idToTestTasks, sourcePropertyIds);
   const newContent = replaceTraceabilitySection(content, newSection);
   if (newContent === content) return false;
-  await writeFile(filePath, newContent, "utf-8");
+  await writeFile2(filePath, newContent, "utf-8");
   return true;
 }
 function parseTaskFileData(content, crossRefPatterns) {
@@ -663,7 +858,7 @@ function extractIdsFromText(text) {
   return ids;
 }
 function extractCodeFromFileName(fileName) {
-  const match = /^(?:REQ|DESIGN|FEAT|EXAMPLES|API|TASK)-([A-Z][A-Z0-9]*)-/.exec(fileName);
+  const match = /^(?:REQ|DESIGN|FEAT|EXAMPLE|API|TASK)-([A-Z][A-Z0-9]*)-/.exec(fileName);
   return match?.[1] ?? "";
 }
 function compareIds(a, b) {
@@ -745,7 +940,7 @@ function printRuleContext(f) {
 }
 
 // src/core/check/rule-loader.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { join } from "path";
 import { parse as parseYaml } from "yaml";
 async function loadRules(schemaDir) {
@@ -766,7 +961,7 @@ function matchesTargetGlob(filePath, targetGlob) {
 async function loadRuleFile(filePath) {
   let content;
   try {
-    content = await readFile3(filePath, "utf-8");
+    content = await readFile4(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -958,7 +1153,7 @@ var RuleValidationError = class extends Error {
 };
 
 // src/core/check/schema-checker.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import remarkGfm from "remark-gfm";
 import remarkParse from "remark-parse";
 import { unified } from "unified";
@@ -1000,14 +1195,18 @@ function formatProhibitedRule(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));
+  for (const spec2 of specFiles) {
+    const matchingRules = ruleSets.filter((rs) => matchesTargetGlob(spec2.filePath, rs.targetGlob));
     if (matchingRules.length === 0) continue;
     let content;
-    try {
-      content = await readFile4(spec.filePath, "utf-8");
-    } catch {
-      continue;
+    if (spec2.content != null) {
+      content = spec2.content;
+    } else {
+      try {
+        content = await readFile5(spec2.filePath, "utf-8");
+      } catch {
+        continue;
+      }
     }
     const tree = parser.parse(content);
     const sectionTree = buildSectionTree(tree);
@@ -1021,7 +1220,7 @@ async function checkSchemasAsync(specFiles, ruleSets) {
             severity: "warning",
             code: "schema-line-limit",
             message: `File has ${lineCount} lines, exceeds limit of ${ruleSet.ruleFile["line-limit"]}`,
-            filePath: spec.filePath,
+            filePath: spec2.filePath,
             ruleSource,
             rule: formatLineLimitRule(ruleSet.ruleFile["line-limit"])
           });
@@ -1031,7 +1230,7 @@ async function checkSchemasAsync(specFiles, ruleSets) {
         ...checkRulesAgainstSections(
           allSections,
           ruleSet.ruleFile.sections,
-          spec.filePath,
+          spec2.filePath,
           ruleSource
         )
       );
@@ -1040,7 +1239,7 @@ async function checkSchemasAsync(specFiles, ruleSets) {
           ...checkProhibited(
             content,
             ruleSet.ruleFile["sections-prohibited"],
-            spec.filePath,
+            spec2.filePath,
             ruleSource
           )
         );
@@ -1449,131 +1648,6 @@ function collectAllCodeBlocks(section) {
   return blocks;
 }
 
-// src/core/check/spec-parser.ts
-import { readFile as readFile5 } from "fs/promises";
-import { basename as basename2 } 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);
-      }
-    }
-  }
-  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 readFile5(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 componentImplements = /* @__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*$/;
-  let currentComponent = null;
-  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 });
-        currentComponent = compMatch[1];
-      }
-    }
-    if (/^#{1,2}\s/.test(line) && !compMatch) {
-      currentComponent = null;
-    }
-    for (const pattern of crossRefPatterns) {
-      const patIdx = line.indexOf(pattern);
-      if (patIdx !== -1) {
-        const afterPattern = line.slice(patIdx + pattern.length);
-        const ids = extractIdsFromText2(afterPattern);
-        if (ids.length > 0) {
-          const type = pattern.toLowerCase().includes("implements") ? "implements" : "validates";
-          crossRefs.push({ type, ids, filePath, line: i + 1 });
-          if (type === "implements" && currentComponent) {
-            const existing = componentImplements.get(currentComponent) ?? [];
-            existing.push(...ids);
-            componentImplements.set(currentComponent, existing);
-          }
-        }
-      }
-    }
-  }
-  return {
-    filePath,
-    code,
-    requirementIds,
-    acIds,
-    propertyIds,
-    componentNames,
-    crossRefs,
-    idLocations,
-    componentImplements
-  };
-}
-function extractCodePrefix(filePath) {
-  const name = basename2(filePath, ".md");
-  const match = /^(?:REQ|DESIGN|FEAT|EXAMPLES|API)-([A-Z][A-Z0-9]*)-/.exec(name);
-  if (match?.[1]) return match[1];
-  return "";
-}
-function extractIdsFromText2(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 = [];
@@ -1658,44 +1732,6 @@ function checkSpecAgainstSpec(specs, markers, config) {
   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,
-  fix: true
-};
-
 // src/commands/check.ts
 async function checkCommand(cliOptions) {
   try {
@@ -1712,6 +1748,21 @@ async function checkCommand(cliOptions) {
     ]);
     const codeSpecResult = config.specOnly ? { findings: [] } : checkCodeAgainstSpec(markers, specs, config);
     const specSpecResult = checkSpecAgainstSpec(specs, markers, config);
+    if (config.fix) {
+      const fixResult = await fixMatrices(specs, config.crossRefPatterns);
+      if (fixResult.filesFixed > 0) {
+        logger.info(`Fixed traceability matrices in ${fixResult.filesFixed} file(s)`);
+      }
+      const codesFixResult = await fixCodesTable(specs, config);
+      if (codesFixResult.filesFixed > 0) {
+        logger.info("Fixed Feature Codes table in ARCHITECTURE.md");
+      }
+      if (codesFixResult.emptyScopeCodes.length > 0) {
+        logger.warn(
+          `Feature codes missing Scope Boundary: ${codesFixResult.emptyScopeCodes.join(", ")}`
+        );
+      }
+    }
     const schemaResult = config.schemaEnabled && ruleSets.length > 0 ? await checkSchemasAsync(specs.specFiles, ruleSets) : { findings: [] };
     const combinedFindings = [
       ...markers.findings,
@@ -1730,12 +1781,6 @@ async function checkCommand(cliOptions) {
     } else {
       report(allFindings, config.format);
     }
-    if (config.fix) {
-      const fixResult = await fixMatrices(specs, config.crossRefPatterns);
-      if (fixResult.filesFixed > 0) {
-        logger.info(`Fixed traceability matrices in ${fixResult.filesFixed} file(s)`);
-      }
-    }
     const hasErrors = allFindings.some((f) => f.severity === "error");
     return hasErrors ? 1 : 0;
   } catch (error) {
@@ -1797,6 +1842,98 @@ function toStringArray(value) {
   return null;
 }
 
+// src/core/codes/reporter.ts
+import chalk2 from "chalk";
+function formatDocs(docs) {
+  return [
+    docs.feat ? "F" : "\xB7",
+    docs.req ? "R" : "\xB7",
+    docs.design ? "D" : "\xB7",
+    docs.api ? "A" : "\xB7",
+    docs.example ? "E" : "\xB7"
+  ].join("");
+}
+function buildJsonOutput(result) {
+  return {
+    codes: result.codes.map((c) => ({
+      code: c.code,
+      feature: c.feature,
+      reqCount: c.reqCount,
+      docs: formatDocs(c.docs),
+      scope: c.scope
+    })),
+    totalCodes: result.codes.length
+  };
+}
+function formatJson(result) {
+  return JSON.stringify(buildJsonOutput(result), null, 2);
+}
+function formatTable(result) {
+  const { codes } = result;
+  if (codes.length === 0) {
+    return chalk2.yellow("No feature codes found.");
+  }
+  const codeWidth = Math.max(4, ...codes.map((c) => c.code.length));
+  const featureWidth = Math.max(7, ...codes.map((c) => c.feature.length));
+  const reqWidth = 4;
+  const docsWidth = 5;
+  const header = [
+    "CODE".padEnd(codeWidth),
+    "Feature".padEnd(featureWidth),
+    "Reqs".padStart(reqWidth),
+    "Docs".padEnd(docsWidth),
+    "Scope"
+  ].join("  ");
+  const separator = [
+    "\u2500".repeat(codeWidth),
+    "\u2500".repeat(featureWidth),
+    "\u2500".repeat(reqWidth),
+    "\u2500".repeat(docsWidth),
+    "\u2500".repeat(40)
+  ].join("  ");
+  const rows = codes.map((c) => {
+    const docs = formatDocs(c.docs);
+    return [
+      chalk2.cyan(c.code.padEnd(codeWidth)),
+      c.feature.padEnd(featureWidth),
+      String(c.reqCount).padStart(reqWidth),
+      docs,
+      chalk2.dim(c.scope)
+    ].join("  ");
+  });
+  return [chalk2.bold(`Feature codes (${codes.length}):
+`), header, separator, ...rows].join("\n");
+}
+function formatSummary(result) {
+  return `codes: ${result.codes.length}`;
+}
+
+// src/commands/codes.ts
+async function codesCommand(options) {
+  try {
+    const { specs, config } = await scan(options.config);
+    const result = await scanCodes(specs.specFiles, config.specGlobs, config.specIgnore);
+    if (options.summary) {
+      process.stdout.write(`${formatSummary(result)}
+`);
+    } else if (options.json) {
+      process.stdout.write(`${formatJson(result)}
+`);
+    } else {
+      process.stdout.write(`${formatTable(result)}
+`);
+    }
+    return 0;
+  } catch (err) {
+    if (err instanceof Error) {
+      logger.error(err.message);
+    } else {
+      logger.error(String(err));
+    }
+    return 2;
+  }
+}
+
 // src/commands/diff.ts
 import { intro, outro } from "@clack/prompts";
 
@@ -1905,7 +2042,7 @@ import { join as join3, relative } from "path";
 // src/core/resolver.ts
 import { MultiSelectPrompt } from "@clack/core";
 import { isCancel, multiselect } from "@clack/prompts";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var _unicode = process.platform !== "win32";
 var _s = (c, fb) => _unicode ? c : fb;
 var _CHECKED = _s("\u25FC", "[+]");
@@ -1915,20 +2052,20 @@ var _BAR = _s("\u2502", "|");
 var _BAR_END = _s("\u2514", "-");
 function _renderDeleteItem(opt, state) {
   const label = opt.label ?? opt.value;
-  const hint = opt.hint ? ` ${chalk2.dim(`(${opt.hint})`)}` : "";
+  const hint = opt.hint ? ` ${chalk3.dim(`(${opt.hint})`)}` : "";
   switch (state) {
     case "active":
-      return `${chalk2.cyan(_UNCHECKED_A)} ${label}${hint}`;
+      return `${chalk3.cyan(_UNCHECKED_A)} ${label}${hint}`;
     case "selected":
-      return `${chalk2.red(_CHECKED)} ${chalk2.dim(label)}${hint}`;
+      return `${chalk3.red(_CHECKED)} ${chalk3.dim(label)}${hint}`;
     case "active-selected":
-      return `${chalk2.red(_CHECKED)} ${label}${hint}`;
+      return `${chalk3.red(_CHECKED)} ${label}${hint}`;
     case "cancelled":
-      return chalk2.strikethrough(chalk2.dim(label));
+      return chalk3.strikethrough(chalk3.dim(label));
     case "submitted":
-      return chalk2.dim(label);
+      return chalk3.dim(label);
     default:
-      return `${chalk2.dim(_UNCHECKED)} ${chalk2.dim(label)}`;
+      return `${chalk3.dim(_UNCHECKED)} ${chalk3.dim(label)}`;
   }
 }
 async function deleteMultiselect(opts) {
@@ -1939,8 +2076,8 @@ async function deleteMultiselect(opts) {
     required,
     render() {
       const self = this;
-      const header = `${chalk2.gray(_BAR)}
-${chalk2.cyan(_BAR)}  ${message}
+      const header = `${chalk3.gray(_BAR)}
+${chalk3.cyan(_BAR)}  ${message}
 `;
       const getState = (opt, idx) => {
         const active = idx === self.cursor;
@@ -1952,16 +2089,16 @@ ${chalk2.cyan(_BAR)}  ${message}
       };
       switch (self.state) {
         case "submit":
-          return `${header}${chalk2.gray(_BAR)}  ` + (self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "submitted")).join(chalk2.dim(", ")) || chalk2.dim("none"));
+          return `${header}${chalk3.gray(_BAR)}  ` + (self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "submitted")).join(chalk3.dim(", ")) || chalk3.dim("none"));
         case "cancel": {
-          const cancelled = self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "cancelled")).join(chalk2.dim(", "));
-          return `${header}${chalk2.gray(_BAR)}  ${cancelled.trim() ? `${cancelled}
-${chalk2.gray(_BAR)}` : chalk2.dim("none")}`;
+          const cancelled = self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "cancelled")).join(chalk3.dim(", "));
+          return `${header}${chalk3.gray(_BAR)}  ${cancelled.trim() ? `${cancelled}
+${chalk3.gray(_BAR)}` : chalk3.dim("none")}`;
         }
         default:
-          return `${header}${chalk2.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
-${chalk2.cyan(_BAR)}  `) + `
-${chalk2.cyan(_BAR_END)}
+          return `${header}${chalk3.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
+${chalk3.cyan(_BAR)}  `) + `
+${chalk3.cyan(_BAR_END)}
 `;
       }
     }
@@ -2057,11 +2194,9 @@ var EMPTY_FILE_MARKER = "<!-- AWA:EMPTY_FILE -->";
 var TemplateEngine = class {
   eta = null;
   templateDir = null;
-  compiledCache = /* @__PURE__ */ new Map();
   // @awa-impl: TPL-8_AC-1, TPL-8_AC-2, TPL-8_AC-3, TPL-8_AC-4
   configure(templateDir) {
     this.templateDir = templateDir;
-    this.compiledCache.clear();
     this.eta = new Eta({
       views: templateDir,
       cache: true,
@@ -2882,7 +3017,7 @@ async function diffCommand(cliOptions) {
 import { intro as intro2, outro as outro2 } from "@clack/prompts";
 
 // src/core/features/reporter.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 var FeaturesReporter = class {
   // @awa-impl: DISC-6_AC-1, DISC-7_AC-1
   /** Render the features report to stdout. */
@@ -2917,25 +3052,25 @@ var FeaturesReporter = class {
   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)`));
+      console.log(chalk4.yellow("No feature flags found."));
+      console.log(chalk4.dim(`(${filesScanned} files scanned)`));
       return;
     }
-    console.log(chalk3.bold(`Feature flags (${features.length} found):
+    console.log(chalk4.bold(`Feature flags (${features.length} found):
 `));
     for (const feature of features) {
-      console.log(`  ${chalk3.cyan(feature.name)}`);
+      console.log(`  ${chalk4.cyan(feature.name)}`);
       for (const file of feature.files) {
-        console.log(`    ${chalk3.dim(file)}`);
+        console.log(`    ${chalk4.dim(file)}`);
       }
     }
     console.log("");
-    console.log(chalk3.dim(`${filesScanned} files scanned`));
+    console.log(chalk4.dim(`${filesScanned} files scanned`));
     if (presets && Object.keys(presets).length > 0) {
       console.log("");
-      console.log(chalk3.bold("Presets (from .awa.toml):\n"));
+      console.log(chalk4.bold("Presets (from .awa.toml):\n"));
       for (const [name, flags] of Object.entries(presets)) {
-        console.log(`  ${chalk3.green(name)}: ${flags.join(", ")}`);
+        console.log(`  ${chalk4.green(name)}: ${flags.join(", ")}`);
       }
     }
   }
@@ -3168,25 +3303,665 @@ async function generateCommand(cliOptions) {
   }
 }
 
+// src/core/merge/content-merger.ts
+import { readFile as readFile7, rename, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename4, dirname, extname, join as join8 } from "path";
+var MERGE_PREFIXES = ["FEAT", "REQ", "DESIGN", "API", "EXAMPLE", "TASK"];
+function resolveMovePath(sourceFilePath, prefix, sourceCode, targetCode, existingPaths, plannedPaths) {
+  const dir = dirname(sourceFilePath);
+  const name = basename4(sourceFilePath);
+  const newName = name.replace(`${prefix}-${sourceCode}-`, `${prefix}-${targetCode}-`);
+  const newPath = join8(dir, newName);
+  if (!existingPaths.has(newPath) && !plannedPaths.has(newPath)) {
+    return newPath;
+  }
+  const ext = extname(newName);
+  const stem = newName.slice(0, -ext.length);
+  for (let i = 1; i < 1e3; i++) {
+    const indexed = join8(dir, `${stem}-${String(i).padStart(3, "0")}${ext}`);
+    if (!existingPaths.has(indexed) && !plannedPaths.has(indexed)) {
+      return indexed;
+    }
+  }
+  throw new Error(`Cannot resolve conflict for ${sourceFilePath}`);
+}
+function updateHeading(content, sourceCode, targetCode) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#\s/.test(line)) {
+      lines[i] = line.replaceAll(sourceCode, targetCode);
+      break;
+    }
+  }
+  return lines.join("\n");
+}
+async function executeMoves(sourceCode, targetCode, specFiles, dryRun) {
+  const moves = [];
+  const sourceFilePaths = /* @__PURE__ */ new Set();
+  for (const sf of specFiles) {
+    const name = basename4(sf.filePath);
+    for (const prefix of MERGE_PREFIXES) {
+      if (name.startsWith(`${prefix}-${sourceCode}-`)) {
+        sourceFilePaths.add(sf.filePath);
+        break;
+      }
+    }
+  }
+  const existingPaths = new Set(
+    specFiles.map((sf) => sf.filePath).filter((p) => !sourceFilePaths.has(p))
+  );
+  const plannedPaths = /* @__PURE__ */ new Set();
+  for (const sf of specFiles) {
+    const name = basename4(sf.filePath);
+    let matchedPrefix = "";
+    for (const prefix of MERGE_PREFIXES) {
+      if (name.startsWith(`${prefix}-${sourceCode}-`)) {
+        matchedPrefix = prefix;
+        break;
+      }
+    }
+    if (!matchedPrefix) continue;
+    const targetPath = resolveMovePath(
+      sf.filePath,
+      matchedPrefix,
+      sourceCode,
+      targetCode,
+      existingPaths,
+      plannedPaths
+    );
+    plannedPaths.add(targetPath);
+    moves.push({
+      sourceFile: sf.filePath,
+      targetFile: targetPath,
+      docType: matchedPrefix
+    });
+    if (!dryRun) {
+      const content = await readFile7(sf.filePath, "utf-8");
+      const updated = updateHeading(content, sourceCode, targetCode);
+      await rename(sf.filePath, targetPath);
+      if (updated !== content) {
+        await writeFile3(targetPath, updated, "utf-8");
+      }
+    }
+  }
+  return moves;
+}
+
+// src/core/merge/reporter.ts
+function formatText(result, dryRun) {
+  const lines = [];
+  if (dryRun) {
+    lines.push("DRY RUN \u2014 no files were modified\n");
+  }
+  if (result.noChange) {
+    lines.push(`${result.sourceCode} \u2192 ${result.targetCode}: nothing to merge`);
+    return lines.join("\n");
+  }
+  lines.push(
+    `${result.sourceCode} \u2192 ${result.targetCode}: ${result.map.entries.size} ID(s) recoded
+`
+  );
+  if (result.map.entries.size > 0) {
+    lines.push("  Old ID \u2192 New ID");
+    lines.push(`  ${"\u2500".repeat(40)}`);
+    for (const [oldId, newId] of result.map.entries) {
+      lines.push(`  ${oldId} \u2192 ${newId}`);
+    }
+  }
+  if (result.moves.length > 0) {
+    lines.push("");
+    lines.push(`  ${result.moves.length} file(s) moved:`);
+    for (const m of result.moves) {
+      lines.push(`    ${m.sourceFile} \u2192 ${m.targetFile} (${m.docType})`);
+    }
+  }
+  if (result.affectedFiles.length > 0) {
+    lines.push("");
+    lines.push(
+      `  ${result.totalReplacements} replacement(s) in ${result.affectedFiles.length} file(s):`
+    );
+    for (const file of result.affectedFiles) {
+      lines.push(`    ${file.filePath} (${file.replacements.length})`);
+    }
+  }
+  if (result.staleRefs.length > 0) {
+    lines.push("");
+    lines.push(`  \u2716 ${result.staleRefs.length} file(s) still reference ${result.sourceCode}:`);
+    for (const ref of result.staleRefs) {
+      lines.push(`    ${ref}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatJson2(result) {
+  const output = {
+    sourceCode: result.sourceCode,
+    targetCode: result.targetCode,
+    noChange: result.noChange,
+    map: Object.fromEntries(result.map.entries),
+    moves: result.moves.map((m) => ({
+      sourceFile: m.sourceFile,
+      targetFile: m.targetFile,
+      docType: m.docType
+    })),
+    staleRefs: result.staleRefs,
+    affectedFiles: result.affectedFiles.map((f) => ({
+      filePath: f.filePath,
+      replacements: f.replacements.map((r) => ({
+        line: r.line,
+        oldId: r.oldId,
+        newId: r.newId
+      }))
+    })),
+    totalReplacements: result.totalReplacements
+  };
+  return JSON.stringify(output, null, 2);
+}
+
+// src/core/merge/spec-mover.ts
+import { readFile as readFile8, rename as rename2 } from "fs/promises";
+import { basename as basename5, dirname as dirname2, join as join9 } from "path";
+
+// src/core/merge/types.ts
+var MergeError = class extends Error {
+  errorCode;
+  constructor(errorCode, message) {
+    super(message);
+    this.name = "MergeError";
+    this.errorCode = errorCode;
+  }
+};
+
+// src/core/merge/spec-mover.ts
+var CODE_PREFIXES = ["REQ", "DESIGN", "FEAT", "TASK", "EXAMPLE"];
+function resolveFeatureName(code, specFiles) {
+  for (const sf of specFiles) {
+    const name = basename5(sf.filePath, ".md");
+    const match = new RegExp(`^REQ-${code}-(.+)$`).exec(name);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
+function planRenames(sourceCode, targetCode, specFiles) {
+  const targetFeature = resolveFeatureName(targetCode, specFiles);
+  const renames = [];
+  for (const sf of specFiles) {
+    const name = basename5(sf.filePath);
+    for (const prefix of CODE_PREFIXES) {
+      const oldPrefix = `${prefix}-${sourceCode}-`;
+      if (name.startsWith(oldPrefix)) {
+        const oldSuffix = name.slice(oldPrefix.length);
+        const newSuffix = targetFeature ? replaceFeaturePart(oldSuffix, targetFeature) : oldSuffix;
+        const newName = `${prefix}-${targetCode}-${newSuffix}`;
+        const newPath = join9(dirname2(sf.filePath), newName);
+        renames.push({ oldPath: sf.filePath, newPath });
+        break;
+      }
+    }
+  }
+  return renames;
+}
+function replaceFeaturePart(suffix, targetFeature) {
+  const numericMatch = /^(.+)-(\d+\.md)$/.exec(suffix);
+  if (numericMatch) {
+    return `${targetFeature}-${numericMatch[2]}`;
+  }
+  if (suffix.endsWith(".md")) {
+    return `${targetFeature}.md`;
+  }
+  return suffix;
+}
+function detectConflicts(renames, specFiles) {
+  const existingPaths = new Set(specFiles.map((sf) => sf.filePath));
+  const conflicts = [];
+  for (const r of renames) {
+    if (existingPaths.has(r.newPath)) {
+      conflicts.push(r.newPath);
+    }
+  }
+  return conflicts;
+}
+function updateHeading2(content, sourceCode, targetCode) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#\s/.test(line)) {
+      lines[i] = line.replaceAll(sourceCode, targetCode);
+      break;
+    }
+  }
+  return lines.join("\n");
+}
+async function executeRenames(renames, sourceCode, targetCode, dryRun) {
+  if (dryRun) return renames;
+  for (const r of renames) {
+    const content = await readFile8(r.oldPath, "utf-8");
+    const updated = updateHeading2(content, sourceCode, targetCode);
+    await rename2(r.oldPath, r.newPath);
+    if (updated !== content) {
+      const { writeFile: writeFile5 } = await import("fs/promises");
+      await writeFile5(r.newPath, updated, "utf-8");
+    }
+  }
+  return renames;
+}
+async function findStaleRefs(sourceCode, specFiles) {
+  const stale = [];
+  const pattern = new RegExp(`\\b${sourceCode}-\\d`, "g");
+  for (const sf of specFiles) {
+    let content;
+    try {
+      content = await readFile8(sf.filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (pattern.test(content)) {
+      stale.push(sf.filePath);
+    }
+    pattern.lastIndex = 0;
+  }
+  return stale;
+}
+function validateMerge(sourceCode, targetCode) {
+  if (sourceCode === targetCode) {
+    throw new MergeError("SELF_MERGE", `Cannot merge a code into itself: ${sourceCode}`);
+  }
+}
+
+// src/core/recode/map-builder.ts
+import { basename as basename6 } from "path";
+
+// src/core/recode/types.ts
+var RecodeError = class extends Error {
+  errorCode;
+  constructor(errorCode, message) {
+    super(message);
+    this.name = "RecodeError";
+    this.errorCode = errorCode;
+  }
+};
+
+// src/core/recode/map-builder.ts
+function buildRecodeMap(sourceCode, targetCode, specs) {
+  if (!hasAnySpecFile(specs.specFiles, sourceCode)) {
+    throw new RecodeError("SOURCE_NOT_FOUND", `No spec files found for source code: ${sourceCode}`);
+  }
+  const entries = /* @__PURE__ */ new Map();
+  const sourceReq = findSpecFile(specs.specFiles, sourceCode, "REQ");
+  if (sourceReq) {
+    const targetReq = findSpecFile(specs.specFiles, targetCode, "REQ");
+    const reqOffset = targetReq ? findHighestReqNumber(targetReq) : 0;
+    buildRequirementEntries(sourceCode, targetCode, sourceReq, reqOffset, entries);
+  }
+  const sourceDesign = findSpecFile(specs.specFiles, sourceCode, "DESIGN");
+  const targetDesign = findSpecFile(specs.specFiles, targetCode, "DESIGN");
+  if (sourceDesign) {
+    const propOffset = targetDesign ? findHighestPropertyNumber(targetDesign) : 0;
+    buildPropertyEntries(sourceCode, targetCode, sourceDesign, propOffset, entries);
+  }
+  if (sourceDesign) {
+    buildComponentEntries(sourceCode, targetCode, sourceDesign, entries);
+  }
+  const noChange = entries.size === 0;
+  const map = { code: sourceCode, entries };
+  return { map, noChange };
+}
+function buildRequirementEntries(_sourceCode, targetCode, sourceReq, reqOffset, entries) {
+  const topLevelReqs = [];
+  const subReqsByParent = /* @__PURE__ */ new Map();
+  for (const id of sourceReq.requirementIds) {
+    if (id.includes(".")) {
+      const dotIdx = id.lastIndexOf(".");
+      const parent = id.slice(0, dotIdx);
+      const subs = subReqsByParent.get(parent) ?? [];
+      subs.push(id);
+      subReqsByParent.set(parent, subs);
+    } else {
+      topLevelReqs.push(id);
+    }
+  }
+  const reqNumberMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < topLevelReqs.length; i++) {
+    const oldId = topLevelReqs[i];
+    const newNum = reqOffset + i + 1;
+    const newId = `${targetCode}-${newNum}`;
+    entries.set(oldId, newId);
+    reqNumberMap.set(oldId, newNum);
+  }
+  for (const oldParentId of topLevelReqs) {
+    const subs = subReqsByParent.get(oldParentId);
+    if (!subs) continue;
+    const newParentNum = reqNumberMap.get(oldParentId);
+    if (newParentNum === void 0) continue;
+    for (let j = 0; j < subs.length; j++) {
+      const oldSubId = subs[j];
+      const newSubNum = j + 1;
+      const newSubId = `${targetCode}-${newParentNum}.${newSubNum}`;
+      entries.set(oldSubId, newSubId);
+    }
+  }
+  const acsByParent = /* @__PURE__ */ new Map();
+  for (const acId of sourceReq.acIds) {
+    const parent = acId.split("_AC-")[0];
+    const acs = acsByParent.get(parent) ?? [];
+    acs.push(acId);
+    acsByParent.set(parent, acs);
+  }
+  for (const [oldParentId, acs] of acsByParent) {
+    const newParentId = entries.get(oldParentId) ?? oldParentId;
+    for (let k = 0; k < acs.length; k++) {
+      const oldAcId = acs[k];
+      const newAcNum = k + 1;
+      const newAcId = `${newParentId}_AC-${newAcNum}`;
+      entries.set(oldAcId, newAcId);
+    }
+  }
+}
+function buildPropertyEntries(_sourceCode, targetCode, sourceDesign, propOffset, entries) {
+  for (let i = 0; i < sourceDesign.propertyIds.length; i++) {
+    const oldId = sourceDesign.propertyIds[i];
+    const newNum = propOffset + i + 1;
+    const newId = `${targetCode}_P-${newNum}`;
+    entries.set(oldId, newId);
+  }
+}
+function buildComponentEntries(sourceCode, targetCode, sourceDesign, entries) {
+  for (const compName of sourceDesign.componentNames) {
+    const prefix = `${sourceCode}-`;
+    if (compName.startsWith(prefix)) {
+      const suffix = compName.slice(prefix.length);
+      entries.set(compName, `${targetCode}-${suffix}`);
+    }
+  }
+}
+function findHighestReqNumber(reqFile) {
+  let max = 0;
+  for (const id of reqFile.requirementIds) {
+    if (id.includes(".")) continue;
+    const match = id.match(/-(\d+)$/);
+    if (match) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+  return max;
+}
+function findHighestPropertyNumber(designFile) {
+  let max = 0;
+  for (const id of designFile.propertyIds) {
+    const match = id.match(/_P-(\d+)$/);
+    if (match) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+  return max;
+}
+function findSpecFile(specFiles, code, prefix) {
+  return specFiles.find((sf) => {
+    const name = basename6(sf.filePath);
+    return name.startsWith(`${prefix}-${code}-`);
+  });
+}
+var SPEC_PREFIXES = ["FEAT", "REQ", "DESIGN", "EXAMPLE", "API", "TASK"];
+function hasAnySpecFile(specFiles, code) {
+  return specFiles.some((sf) => {
+    const name = basename6(sf.filePath);
+    return SPEC_PREFIXES.some((prefix) => name.startsWith(`${prefix}-${code}-`));
+  });
+}
+
+// src/commands/merge.ts
+async function mergeCommand(options) {
+  try {
+    validateMerge(options.sourceCode, options.targetCode);
+    const { markers, specs } = await scan(options.config);
+    const dryRun = options.dryRun === true;
+    if (!hasAnySpecFile(specs.specFiles, options.targetCode)) {
+      throw new MergeError(
+        "TARGET_NOT_FOUND",
+        `No spec files found for target code: ${options.targetCode}. Use \`awa spec recode\` to rename a code to a new one.`
+      );
+    }
+    const { map, noChange: recodeNoChange } = buildRecodeMap(
+      options.sourceCode,
+      options.targetCode,
+      specs
+    );
+    let affectedFiles = [];
+    let totalReplacements = 0;
+    if (!recodeNoChange) {
+      const result2 = await propagate(map, specs, markers, dryRun);
+      affectedFiles = result2.affectedFiles;
+      totalReplacements = result2.totalReplacements;
+    }
+    const moves = await executeMoves(
+      options.sourceCode,
+      options.targetCode,
+      specs.specFiles,
+      dryRun
+    );
+    const movedSourcePaths = new Set(moves.map((m) => m.sourceFile));
+    const propagatedPaths = new Set(affectedFiles.map((af) => af.filePath));
+    const nonSourceFiles = specs.specFiles.filter(
+      (sf) => !movedSourcePaths.has(sf.filePath) && !propagatedPaths.has(sf.filePath)
+    );
+    const staleRefs = await findStaleRefs(options.sourceCode, nonSourceFiles);
+    const noChange = recodeNoChange && moves.length === 0;
+    const result = {
+      sourceCode: options.sourceCode,
+      targetCode: options.targetCode,
+      map,
+      affectedFiles,
+      totalReplacements,
+      moves,
+      staleRefs,
+      noChange
+    };
+    outputResult(result, dryRun, options.json === true);
+    if (staleRefs.length > 0) {
+      return 2;
+    }
+    if (options.renumber && !dryRun && !noChange) {
+      const { renumberCommand: renumberCommand2 } = await import("./renumber-ZCI2H5HZ.js");
+      await renumberCommand2({
+        code: options.targetCode,
+        dryRun: false,
+        json: options.json,
+        config: options.config
+      });
+    }
+    if (!dryRun && !noChange) {
+      const { specs: freshSpecs, config: scanConfig } = await scan(options.config);
+      await fixCodesTable(freshSpecs, scanConfig);
+    }
+    return noChange ? 0 : 1;
+  } catch (err) {
+    if (err instanceof MergeError) {
+      logger.error(err.message);
+      return 2;
+    }
+    if (err instanceof RecodeError) {
+      logger.error(err.message);
+      return 2;
+    }
+    if (err instanceof Error) {
+      logger.error(err.message);
+    } else {
+      logger.error(String(err));
+    }
+    return 2;
+  }
+}
+function outputResult(result, dryRun, json) {
+  if (json) {
+    process.stdout.write(`${formatJson2(result)}
+`);
+  } else {
+    const text = formatText(result, dryRun);
+    logger.info(text);
+  }
+}
+
+// src/core/recode/reporter.ts
+function formatText2(result, dryRun) {
+  const lines = [];
+  if (dryRun) {
+    lines.push("DRY RUN \u2014 no files were modified\n");
+  }
+  if (result.noChange) {
+    lines.push(`${result.sourceCode} \u2192 ${result.targetCode}: no IDs to recode`);
+    return lines.join("\n");
+  }
+  lines.push(
+    `${result.sourceCode} \u2192 ${result.targetCode}: ${result.map.entries.size} ID(s) recoded
+`
+  );
+  lines.push("  Old ID \u2192 New ID");
+  lines.push(`  ${"\u2500".repeat(40)}`);
+  for (const [oldId, newId] of result.map.entries) {
+    lines.push(`  ${oldId} \u2192 ${newId}`);
+  }
+  if (result.affectedFiles.length > 0) {
+    lines.push("");
+    lines.push(
+      `  ${result.totalReplacements} replacement(s) in ${result.affectedFiles.length} file(s):`
+    );
+    for (const file of result.affectedFiles) {
+      lines.push(`    ${file.filePath} (${file.replacements.length})`);
+    }
+  }
+  if (result.renames.length > 0) {
+    lines.push("");
+    lines.push(`  ${result.renames.length} file(s) renamed:`);
+    for (const r of result.renames) {
+      lines.push(`    ${r.oldPath} \u2192 ${r.newPath}`);
+    }
+  }
+  if (result.staleRefs.length > 0) {
+    lines.push("");
+    lines.push(`  \u2716 ${result.staleRefs.length} file(s) still reference ${result.sourceCode}:`);
+    for (const ref of result.staleRefs) {
+      lines.push(`    ${ref}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatJson3(result) {
+  const output = {
+    sourceCode: result.sourceCode,
+    targetCode: result.targetCode,
+    noChange: result.noChange,
+    map: Object.fromEntries(result.map.entries),
+    affectedFiles: result.affectedFiles.map((f) => ({
+      filePath: f.filePath,
+      replacements: f.replacements.map((r) => ({
+        line: r.line,
+        oldId: r.oldId,
+        newId: r.newId
+      }))
+    })),
+    totalReplacements: result.totalReplacements,
+    renames: result.renames.map((r) => ({ oldPath: r.oldPath, newPath: r.newPath })),
+    staleRefs: result.staleRefs
+  };
+  return JSON.stringify(output, null, 2);
+}
+
+// src/commands/recode.ts
+async function recodeCommand(options) {
+  try {
+    const { markers, specs } = await scan(options.config);
+    const dryRun = options.dryRun === true;
+    const { map, noChange: recodeNoChange } = buildRecodeMap(
+      options.sourceCode,
+      options.targetCode,
+      specs
+    );
+    let affectedFiles = [];
+    let totalReplacements = 0;
+    if (!recodeNoChange) {
+      const result2 = await propagate(map, specs, markers, dryRun);
+      affectedFiles = result2.affectedFiles;
+      totalReplacements = result2.totalReplacements;
+    }
+    const renames = planRenames(options.sourceCode, options.targetCode, specs.specFiles);
+    const conflicts = detectConflicts(renames, specs.specFiles);
+    if (conflicts.length > 0) {
+      throw new RecodeError(
+        "RENAME_CONFLICT",
+        `File rename conflict(s): ${conflicts.join(", ")}. Use \`awa spec merge\` to combine codes with overlapping files.`
+      );
+    }
+    await executeRenames(renames, options.sourceCode, options.targetCode, dryRun);
+    const propagatedPaths = new Set(affectedFiles.map((af) => af.filePath));
+    const nonSourceFiles = specs.specFiles.filter(
+      (sf) => !renames.some((r) => r.oldPath === sf.filePath) && !propagatedPaths.has(sf.filePath)
+    );
+    const staleRefs = await findStaleRefs(options.sourceCode, nonSourceFiles);
+    const noChange = recodeNoChange && renames.length === 0;
+    const result = {
+      sourceCode: options.sourceCode,
+      targetCode: options.targetCode,
+      map,
+      affectedFiles,
+      totalReplacements,
+      renames,
+      staleRefs,
+      noChange
+    };
+    outputResult2(result, dryRun, options.json === true);
+    if (staleRefs.length > 0) {
+      return 2;
+    }
+    if (!dryRun && !noChange) {
+      const { specs: freshSpecs, config: scanConfig } = await scan(options.config);
+      await fixCodesTable(freshSpecs, scanConfig);
+    }
+    return noChange ? 0 : 1;
+  } catch (err) {
+    if (err instanceof RecodeError) {
+      logger.error(err.message);
+      return 2;
+    }
+    if (err instanceof Error) {
+      logger.error(err.message);
+    } else {
+      logger.error(String(err));
+    }
+    return 2;
+  }
+}
+function outputResult2(result, dryRun, json) {
+  if (json) {
+    process.stdout.write(`${formatJson3(result)}
+`);
+  } else {
+    const text = formatText2(result, dryRun);
+    logger.info(text);
+  }
+}
+
 // 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 basename3, extname, join as join8 } from "path";
+import { basename as basename7, extname as extname2, join as join10 } from "path";
 import { parse } from "smol-toml";
 async function discoverFixtures(templatePath) {
-  const testsDir = join8(templatePath, "_tests");
+  const testsDir = join10(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();
+    entries = dirEntries.filter((e) => e.isFile() && extname2(e.name) === ".toml").map((e) => e.name).sort();
   } catch {
     return [];
   }
   const fixtures = [];
   for (const filename of entries) {
-    const filePath = join8(testsDir, filename);
+    const filePath = join10(testsDir, filename);
     const fixture = await parseFixture(filePath);
     fixtures.push(fixture);
   }
@@ -3195,7 +3970,7 @@ async function discoverFixtures(templatePath) {
 async function parseFixture(filePath) {
   const content = await readTextFile(filePath);
   const parsed = parse(content);
-  const name = basename3(filePath, extname(filePath));
+  const name = basename7(filePath, extname2(filePath));
   const features = toStringArray2(parsed.features) ?? [];
   const preset = toStringArray2(parsed.preset) ?? [];
   const removeFeatures = toStringArray2(parsed["remove-features"]) ?? [];
@@ -3217,7 +3992,7 @@ function toStringArray2(value) {
 }
 
 // src/core/template-test/reporter.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 function report2(result, options) {
   if (options?.json) {
     reportJson2(result);
@@ -3228,11 +4003,11 @@ function report2(result, options) {
     reportFixture(fixture);
   }
   console.log("");
-  console.log(chalk4.bold("Test Summary:"));
+  console.log(chalk5.bold("Test Summary:"));
   console.log(`  Total:  ${result.total}`);
-  console.log(chalk4.green(`  Passed: ${result.passed}`));
+  console.log(chalk5.green(`  Passed: ${result.passed}`));
   if (result.failed > 0) {
-    console.log(chalk4.red(`  Failed: ${result.failed}`));
+    console.log(chalk5.red(`  Failed: ${result.failed}`));
   }
   console.log("");
 }
@@ -3258,27 +4033,27 @@ function reportJson2(result) {
   console.log(JSON.stringify(output, null, 2));
 }
 function reportFixture(fixture) {
-  const icon = fixture.passed ? chalk4.green("\u2714") : chalk4.red("\u2716");
+  const icon = fixture.passed ? chalk5.green("\u2714") : chalk5.red("\u2716");
   console.log(`${icon} ${fixture.name}`);
   if (fixture.error) {
-    console.log(chalk4.red(`    Error: ${fixture.error}`));
+    console.log(chalk5.red(`    Error: ${fixture.error}`));
     return;
   }
   const missingFiles = fixture.fileResults.filter((r) => !r.found);
   for (const missing of missingFiles) {
-    console.log(chalk4.red(`    Missing file: ${missing.path}`));
+    console.log(chalk5.red(`    Missing file: ${missing.path}`));
   }
   const snapshotFailures = fixture.snapshotResults.filter((r) => r.status !== "match");
   for (const failure of snapshotFailures) {
     switch (failure.status) {
       case "mismatch":
-        console.log(chalk4.yellow(`    Snapshot mismatch: ${failure.path}`));
+        console.log(chalk5.yellow(`    Snapshot mismatch: ${failure.path}`));
         break;
       case "missing-snapshot":
-        console.log(chalk4.yellow(`    Missing snapshot: ${failure.path}`));
+        console.log(chalk5.yellow(`    Missing snapshot: ${failure.path}`));
         break;
       case "extra-snapshot":
-        console.log(chalk4.yellow(`    Extra snapshot (not in output): ${failure.path}`));
+        console.log(chalk5.yellow(`    Extra snapshot (not in output): ${failure.path}`));
         break;
     }
   }
@@ -3287,16 +4062,16 @@ function reportFixture(fixture) {
 // 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";
+import { join as join12 } 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";
+import { join as join11, 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);
+    const fullPath = join11(dir, entry.name);
     if (entry.isDirectory()) {
       const sub = await walkRelative(fullPath, base);
       results.push(...sub);
@@ -3313,8 +4088,8 @@ async function compareSnapshots(renderedDir, 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);
+    const renderedPath = join11(renderedDir, file);
+    const snapshotPath = join11(snapshotDir, file);
     if (!snapshotSet.has(file)) {
       results.push({ path: file, status: "missing-snapshot" });
       continue;
@@ -3340,8 +4115,8 @@ async function updateSnapshots(renderedDir, snapshotDir) {
   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 srcPath = join11(renderedDir, file);
+    const destPath = join11(snapshotDir, file);
     const content = await readTextFile(srcPath);
     await writeTextFile(destPath, content);
   }
@@ -3349,7 +4124,7 @@ async function updateSnapshots(renderedDir, snapshotDir) {
 
 // src/core/template-test/runner.ts
 async function runFixture(fixture, templatePath, options, presetDefinitions = {}) {
-  const tempDir = join10(tmpdir3(), `awa-test-${fixture.name}-${Date.now()}`);
+  const tempDir = join12(tmpdir3(), `awa-test-${fixture.name}-${Date.now()}`);
   try {
     await mkdir2(tempDir, { recursive: true });
     const features = featureResolver.resolve({
@@ -3368,12 +4143,12 @@ async function runFixture(fixture, templatePath, options, presetDefinitions = {}
     });
     const fileResults = [];
     for (const expectedFile of fixture.expectedFiles) {
-      const fullPath = join10(tempDir, expectedFile);
+      const fullPath = join12(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);
+    const snapshotDir = join12(templatePath, "_tests", fixture.name);
     let snapshotResults = [];
     if (options.updateSnapshots) {
       await updateSnapshots(tempDir, snapshotDir);
@@ -3490,7 +4265,7 @@ async function testCommand(options) {
 }
 
 // src/core/trace/content-assembler.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 var DEFAULT_BEFORE_CONTEXT = 5;
 var DEFAULT_AFTER_CONTEXT = 20;
 async function assembleContent(result, taskPath, contextOptions) {
@@ -3498,8 +4273,9 @@ async function assembleContent(result, taskPath, contextOptions) {
   const afterCtx = contextOptions?.afterContext ?? DEFAULT_AFTER_CONTEXT;
   const sections = [];
   const seen = /* @__PURE__ */ new Set();
+  const fileCache = /* @__PURE__ */ new Map();
   if (taskPath) {
-    const content = await safeReadFile(taskPath);
+    const content = await cachedReadFile(fileCache, taskPath);
     if (content) {
       const lineCount = content.split("\n").length;
       sections.push({
@@ -3518,6 +4294,7 @@ async function assembleContent(result, taskPath, contextOptions) {
       if (!seen.has(key)) {
         seen.add(key);
         const section = await extractSpecSection(
+          fileCache,
           chain.requirement.location.filePath,
           chain.requirement.id,
           chain.requirement.location.line,
@@ -3533,6 +4310,7 @@ async function assembleContent(result, taskPath, contextOptions) {
         seen.add(key);
         if (!chain.requirement || ac.location.filePath !== chain.requirement.location.filePath) {
           const section = await extractSpecSection(
+            fileCache,
             ac.location.filePath,
             ac.id,
             ac.location.line,
@@ -3548,6 +4326,7 @@ async function assembleContent(result, taskPath, contextOptions) {
       if (!seen.has(key)) {
         seen.add(key);
         const section = await extractSpecSection(
+          fileCache,
           comp.location.filePath,
           comp.id,
           comp.location.line,
@@ -3562,6 +4341,7 @@ async function assembleContent(result, taskPath, contextOptions) {
       if (!seen.has(key)) {
         seen.add(key);
         const section = await extractCodeSection(
+          fileCache,
           impl.location.filePath,
           impl.location.line,
           "implementation",
@@ -3577,6 +4357,7 @@ async function assembleContent(result, taskPath, contextOptions) {
       if (!seen.has(key)) {
         seen.add(key);
         const section = await extractCodeSection(
+          fileCache,
           t.location.filePath,
           t.location.line,
           "test",
@@ -3592,6 +4373,7 @@ async function assembleContent(result, taskPath, contextOptions) {
       if (!seen.has(key)) {
         seen.add(key);
         const section = await extractSpecSection(
+          fileCache,
           prop.location.filePath,
           prop.id,
           prop.location.line,
@@ -3605,8 +4387,8 @@ async function assembleContent(result, taskPath, contextOptions) {
   sections.sort((a, b) => a.priority - b.priority);
   return sections;
 }
-async function extractSpecSection(filePath, _id, line, type, priority) {
-  const content = await safeReadFile(filePath);
+async function extractSpecSection(fileCache, filePath, _id, line, type, priority) {
+  const content = await cachedReadFile(fileCache, filePath);
   if (!content) return null;
   const lines = content.split("\n");
   let startIdx = line - 1;
@@ -3630,8 +4412,8 @@ async function extractSpecSection(filePath, _id, line, type, priority) {
     priority
   };
 }
-async function extractCodeSection(filePath, line, type, priority, beforeContext = DEFAULT_BEFORE_CONTEXT, afterContext = DEFAULT_AFTER_CONTEXT) {
-  const content = await safeReadFile(filePath);
+async function extractCodeSection(fileCache, filePath, line, type, priority, beforeContext = DEFAULT_BEFORE_CONTEXT, afterContext = DEFAULT_AFTER_CONTEXT) {
+  const content = await cachedReadFile(fileCache, filePath);
   if (!content) return null;
   const lines = content.split("\n");
   const lineIdx = line - 1;
@@ -3687,12 +4469,16 @@ function findEnclosingBlock(lines, lineIdx, beforeContext = DEFAULT_BEFORE_CONTE
   }
   return { start, end };
 }
-async function safeReadFile(filePath) {
+async function cachedReadFile(cache, filePath) {
+  if (cache.has(filePath)) return cache.get(filePath) ?? null;
+  let content;
   try {
-    return await readFile7(filePath, "utf-8");
+    content = await readFile9(filePath, "utf-8");
   } catch {
-    return null;
+    content = null;
   }
+  cache.set(filePath, content);
+  return content;
 }
 
 // src/core/trace/content-formatter.ts
@@ -3855,7 +4641,7 @@ function formatList(result) {
   }
   return [...paths].join("\n");
 }
-function formatJson(result) {
+function formatJson4(result) {
   const output = {
     chains: result.chains.map((chain) => ({
       queryId: chain.queryId,
@@ -3921,10 +4707,6 @@ function buildTraceIndex(specs, markers) {
     ...specs.propertyIds,
     ...specs.componentNames
   ]);
-  const idLocations = /* @__PURE__ */ new Map();
-  for (const [id, loc] of specs.idLocations) {
-    idLocations.set(id, loc);
-  }
   return {
     reqToACs,
     acToDesignComponents,
@@ -3935,7 +4717,7 @@ function buildTraceIndex(specs, markers) {
     acToReq,
     componentToACs,
     propertyToACs,
-    idLocations,
+    idLocations: specs.idLocations,
     allIds
   };
 }
@@ -4041,7 +4823,7 @@ function pushToMap(map, key, value) {
 }
 
 // src/core/trace/input-resolver.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 function resolveIds(ids, index) {
   const resolved = [];
   const warnings = [];
@@ -4057,7 +4839,7 @@ function resolveIds(ids, index) {
 async function resolveTaskFile(taskPath, index) {
   let content;
   try {
-    content = await readFile8(taskPath, "utf-8");
+    content = await readFile10(taskPath, "utf-8");
   } catch {
     return { ids: [], warnings: [`Task file not found: ${taskPath}`] };
   }
@@ -4108,7 +4890,7 @@ async function resolveTaskFile(taskPath, index) {
 async function resolveSourceFile(filePath, index) {
   let content;
   try {
-    content = await readFile8(filePath, "utf-8");
+    content = await readFile10(filePath, "utf-8");
   } catch {
     return { ids: [], warnings: [`Source file not found: ${filePath}`] };
   }
@@ -4388,44 +5170,6 @@ function deduplicateNodes(nodes) {
   return result;
 }
 
-// src/core/trace/scanner.ts
-function buildScanConfig(fileConfig, overrides) {
-  const section = fileConfig?.check;
-  return {
-    specGlobs: toStringArray3(section?.["spec-globs"]) ?? [...DEFAULT_CHECK_CONFIG.specGlobs],
-    codeGlobs: toStringArray3(section?.["code-globs"]) ?? [...DEFAULT_CHECK_CONFIG.codeGlobs],
-    specIgnore: toStringArray3(section?.["spec-ignore"]) ?? [...DEFAULT_CHECK_CONFIG.specIgnore],
-    codeIgnore: toStringArray3(section?.["code-ignore"]) ?? [...DEFAULT_CHECK_CONFIG.codeIgnore],
-    ignoreMarkers: toStringArray3(section?.["ignore-markers"]) ?? [
-      ...DEFAULT_CHECK_CONFIG.ignoreMarkers
-    ],
-    markers: toStringArray3(section?.markers) ?? [...DEFAULT_CHECK_CONFIG.markers],
-    idPattern: typeof section?.["id-pattern"] === "string" ? section["id-pattern"] : DEFAULT_CHECK_CONFIG.idPattern,
-    crossRefPatterns: toStringArray3(section?.["cross-ref-patterns"]) ?? [
-      ...DEFAULT_CHECK_CONFIG.crossRefPatterns
-    ],
-    format: DEFAULT_CHECK_CONFIG.format,
-    schemaDir: DEFAULT_CHECK_CONFIG.schemaDir,
-    schemaEnabled: false,
-    allowWarnings: true,
-    specOnly: false,
-    fix: true,
-    ...overrides
-  };
-}
-async function scan(configPath) {
-  const fileConfig = await configLoader.load(configPath ?? null);
-  const config = buildScanConfig(fileConfig);
-  const [markers, specs] = await Promise.all([scanMarkers(config), parseSpecs(config)]);
-  return { markers, specs, config };
-}
-function toStringArray3(value) {
-  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
-    return value;
-  }
-  return null;
-}
-
 // src/core/trace/token-estimator.ts
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -4543,7 +5287,7 @@ async function traceCommand(options) {
     } else if (options.list) {
       output = formatList(result);
     } else if (options.json) {
-      output = formatJson(result);
+      output = formatJson4(result);
     } else {
       output = formatTree(result);
     }
@@ -4565,7 +5309,7 @@ async function traceCommand(options) {
 }
 
 // src/utils/update-check.ts
-import chalk5 from "chalk";
+import chalk6 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));
@@ -4606,28 +5350,28 @@ function printUpdateWarning(log, result) {
   console.log("");
   if (result.isMajorBump) {
     log.warn(
-      chalk5.yellow(
+      chalk6.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"));
+    log.warn(chalk6.dim("  See https://github.com/ncoderz/awa/releases for details"));
   } else {
-    log.warn(chalk5.yellow(`Update available: ${result.current} \u2192 ${result.latest}`));
+    log.warn(chalk6.yellow(`Update available: ${result.current} \u2192 ${result.latest}`));
   }
-  log.warn(chalk5.dim("  Run `npm install -g @ncoderz/awa` to update"));
+  log.warn(chalk6.dim("  Run `npm install -g @ncoderz/awa` to update"));
   console.log("");
 }
 
 // src/utils/update-check-cache.ts
-import { mkdir as mkdir3, readFile as readFile9, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile11, writeFile as writeFile4 } 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");
+import { dirname as dirname3, join as join13 } from "path";
+var CACHE_DIR = join13(homedir(), ".cache", "awa");
+var CACHE_FILE = join13(CACHE_DIR, "update-check.json");
 var DEFAULT_INTERVAL_MS = 864e5;
 async function shouldCheck(intervalMs = DEFAULT_INTERVAL_MS) {
   try {
-    const raw = await readFile9(CACHE_FILE, "utf-8");
+    const raw = await readFile11(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.timestamp !== "number" || typeof data.latestVersion !== "string") {
       return true;
@@ -4639,12 +5383,12 @@ async function shouldCheck(intervalMs = DEFAULT_INTERVAL_MS) {
 }
 async function writeCache(latestVersion) {
   try {
-    await mkdir3(dirname(CACHE_FILE), { recursive: true });
+    await mkdir3(dirname3(CACHE_FILE), { recursive: true });
     const data = {
       timestamp: Date.now(),
       latestVersion
     };
-    await writeFile2(CACHE_FILE, JSON.stringify(data), "utf-8");
+    await writeFile4(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch {
   }
 }
@@ -4771,29 +5515,85 @@ template.command("test").description("Run template test fixtures to verify expec
   process.exit(exitCode);
 });
 program.addCommand(template);
-program.command("trace").description("Explore traceability chains and assemble context from specs, code, and tests").argument("[ids...]", "Traceability ID(s) to trace").option("--all", "Trace all known IDs in the project", false).option("--task <path>", "Resolve IDs from a task file").option("--file <path>", "Resolve IDs from a source file's markers").option("--content", "Output actual file sections instead of locations", false).option("--list", "Output file paths only (no content or tree)", false).option("--max-tokens <n>", "Cap content output size (implies --content)").option("--depth <n>", "Maximum traversal depth").option("--scope <code>", "Limit results to a feature code").option("--direction <dir>", "Traversal direction: both, forward, reverse", "both").option("--no-code", "Exclude source code (spec-only context)").option("--no-tests", "Exclude test files").option("--json", "Output results as JSON", false).option("--summary", "Output compact one-line summary", false).option("-A <n>", "Lines of context after a code marker (--content only; default: 20)").option("-B <n>", "Lines of context before a code marker (--content only; default: 5)").option("-C <n>", "Lines of context before and after (--content only; overrides -A and -B)").option("-c, --config <path>", "Path to configuration file").action(async (ids, options) => {
-  const traceOptions = {
-    ids,
-    all: options.all,
-    task: options.task,
-    file: options.file,
-    content: options.content,
-    list: options.list,
+var spec = new Command("spec").description(
+  "Spec operations (trace, renumber, recode, merge, codes)"
+);
+function configureTraceCommand(cmd) {
+  return cmd.description("Explore traceability chains and assemble context from specs, code, and tests").argument("[ids...]", "Traceability ID(s) to trace").option("--all", "Trace all known IDs in the project", false).option("--task <path>", "Resolve IDs from a task file").option("--file <path>", "Resolve IDs from a source file's markers").option("--content", "Output actual file sections instead of locations", false).option("--list", "Output file paths only (no content or tree)", false).option("--max-tokens <n>", "Cap content output size (implies --content)").option("--depth <n>", "Maximum traversal depth").option("--scope <code>", "Limit results to a feature code").option("--direction <dir>", "Traversal direction: both, forward, reverse", "both").option("--no-code", "Exclude source code (spec-only context)").option("--no-tests", "Exclude test files").option("--json", "Output results as JSON", false).option("--summary", "Output compact one-line summary", false).option("-A <n>", "Lines of context after a code marker (--content only; default: 20)").option("-B <n>", "Lines of context before a code marker (--content only; default: 5)").option("-C <n>", "Lines of context before and after (--content only; overrides -A and -B)").option("-c, --config <path>", "Path to configuration file").action(async (ids, options) => {
+    const traceOptions = {
+      ids,
+      all: options.all,
+      task: options.task,
+      file: options.file,
+      content: options.content,
+      list: options.list,
+      json: options.json,
+      summary: options.summary,
+      maxTokens: options.maxTokens !== void 0 ? Number(options.maxTokens) : void 0,
+      depth: options.depth !== void 0 ? Number(options.depth) : void 0,
+      scope: options.scope,
+      direction: options.direction,
+      noCode: options.code === false,
+      noTests: options.tests === false,
+      beforeContext: options.C !== void 0 ? Number(options.C) : options.B !== void 0 ? Number(options.B) : void 0,
+      afterContext: options.C !== void 0 ? Number(options.C) : options.A !== void 0 ? Number(options.A) : void 0,
+      config: options.config
+    };
+    const exitCode = await traceCommand(traceOptions);
+    process.exit(exitCode);
+  });
+}
+configureTraceCommand(spec.command("trace"));
+function configureRenumberCommand(cmd) {
+  return cmd.description("Renumber traceability IDs to match document order").argument("[code]", "Feature code to renumber (e.g. CHK, TRC)").option("--all", "Renumber all feature codes", false).option("--dry-run", "Preview changes without modifying files", false).option("--json", "Output results as JSON", false).option("-c, --config <path>", "Path to configuration file").action(async (code, options) => {
+    const renumberOptions = {
+      code,
+      all: options.all,
+      dryRun: options.dryRun,
+      json: options.json,
+      config: options.config
+    };
+    const exitCode = await renumberCommand(renumberOptions);
+    process.exit(exitCode);
+  });
+}
+configureRenumberCommand(spec.command("renumber"));
+spec.command("recode").description("Recode traceability IDs from one feature code to another and rename spec files").argument("<source>", "Source feature code to recode from (e.g. CHK)").argument("<target>", "Target feature code to recode into (e.g. CLI)").option("--dry-run", "Preview changes without modifying files", false).option("--json", "Output results as JSON", false).option("--renumber", "Renumber target code after recode", false).option("-c, --config <path>", "Path to configuration file").action(async (source, target, options) => {
+  const recodeOptions = {
+    sourceCode: source,
+    targetCode: target,
+    dryRun: options.dryRun,
+    json: options.json,
+    renumber: options.renumber,
+    config: options.config
+  };
+  const exitCode = await recodeCommand(recodeOptions);
+  process.exit(exitCode);
+});
+spec.command("merge").description("Merge one feature code into another (recode + content merge + cleanup)").argument("<source>", "Source feature code to merge from (e.g. CHK)").argument("<target>", "Target feature code to merge into (e.g. CLI)").option("--dry-run", "Preview changes without modifying files", false).option("--json", "Output results as JSON", false).option("--renumber", "Renumber target code after merge", false).option("-c, --config <path>", "Path to configuration file").action(async (source, target, options) => {
+  const mergeOptions = {
+    sourceCode: source,
+    targetCode: target,
+    dryRun: options.dryRun,
+    json: options.json,
+    renumber: options.renumber,
+    config: options.config
+  };
+  const exitCode = await mergeCommand(mergeOptions);
+  process.exit(exitCode);
+});
+spec.command("codes").description("List all feature codes with requirement counts and scope summaries").option("--json", "Output results as JSON", false).option("--summary", "Output compact one-line summary", false).option("-c, --config <path>", "Path to configuration file").action(async (options) => {
+  const codesOptions = {
     json: options.json,
     summary: options.summary,
-    maxTokens: options.maxTokens !== void 0 ? Number(options.maxTokens) : void 0,
-    depth: options.depth !== void 0 ? Number(options.depth) : void 0,
-    scope: options.scope,
-    direction: options.direction,
-    noCode: options.code === false,
-    noTests: options.tests === false,
-    beforeContext: options.C !== void 0 ? Number(options.C) : options.B !== void 0 ? Number(options.B) : void 0,
-    afterContext: options.C !== void 0 ? Number(options.C) : options.A !== void 0 ? Number(options.A) : void 0,
     config: options.config
   };
-  const exitCode = await traceCommand(traceOptions);
+  const exitCode = await codesCommand(codesOptions);
   process.exit(exitCode);
 });
+program.addCommand(spec);
+configureTraceCommand(program.command("trace"));
+configureRenumberCommand(program.command("renumber", { hidden: true }));
 var updateCheckPromise = null;
 var isJsonOrSummary = process.argv.includes("--json") || process.argv.includes("--summary");
 var isTTY = process.stdout.isTTY === true;
@@ -4801,7 +5601,7 @@ var isDisabledByEnv = !!process.env.NO_UPDATE_NOTIFIER;
 if (!isJsonOrSummary && isTTY && !isDisabledByEnv) {
   updateCheckPromise = (async () => {
     try {
-      const { configLoader: configLoader2 } = await import("./config-WL3SLSP6.js");
+      const { configLoader: configLoader2 } = await import("./config-EJIXC7D7.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"];
@@ -4830,5 +5630,5 @@ program.hook("postAction", async () => {
   } catch {
   }
 });
-program.parseAsync();
+void program.parseAsync();
 //# sourceMappingURL=index.js.map