speckeeper 0.1.0 → 0.2.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk4 from 'chalk';
-import { dirname, join, relative, resolve, extname, basename } from 'path';
+import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
 import { parse } from 'yaml';
 import 'crypto';
@@ -123,6 +123,10 @@ var RelationSchema = z.object({
 z.array(RelationSchema).optional();
 
 // src/core/model.ts
+var specStore = /* @__PURE__ */ new Map();
+function getSpecStore() {
+  return specStore;
+}
 var modelRegistry = /* @__PURE__ */ new Map();
 function registerModel(model) {
   modelRegistry.set(model.id, model);
@@ -130,6 +134,24 @@ function registerModel(model) {
 function getAllModels() {
   return Array.from(modelRegistry.values());
 }
+function registerModelsFromConfig(models) {
+  for (const model of models) {
+    if (model && typeof model === "object" && "id" in model && "schema" in model) {
+      registerModel(model);
+    }
+  }
+}
+function getSpecs(modelId) {
+  const map = specStore.get(modelId);
+  if (!map) return [];
+  return Array.from(map.values());
+}
+function findModelTypeBySpecId(specId) {
+  for (const [modelId, map] of specStore) {
+    if (map.has(specId)) return modelId;
+  }
+  return null;
+}
 
 // src/cli/build.ts
 async function buildCommand(options) {
@@ -142,12 +164,15 @@ async function buildCommand(options) {
   console.log(chalk4.gray(`  Specs:   ${config.specsDir}/`));
   console.log("");
   try {
+    console.log(chalk4.blue("  Loading models..."));
+    registerModelsFromConfig(config.models || []);
+    console.log("");
     ensureDir(join(cwd, config.docsDir));
     ensureDir(join(cwd, config.specsDir));
     const files = [];
     const models = getAllModels();
     if (models.length === 0) {
-      console.log(chalk4.yellow("  No models registered. Run model registration first."));
+      console.log(chalk4.yellow("  No models registered. Add models to speckeeper.config.ts."));
       return;
     }
     console.log(chalk4.blue(`  Processing ${models.length} model types...`));
@@ -159,7 +184,7 @@ async function buildCommand(options) {
         }
         continue;
       }
-      const specs = [];
+      const specs = getSpecs(model.id);
       if (specs.length === 0) {
         if (options.verbose) {
           console.log(chalk4.gray(`    ${model.name}: no specs found`));
@@ -206,244 +231,9 @@ async function buildCommand(options) {
     process.exit(1);
   }
 }
-function createEmptyRegistry() {
-  return {
-    requirements: /* @__PURE__ */ new Map(),
-    useCases: /* @__PURE__ */ new Map(),
-    actors: /* @__PURE__ */ new Map(),
-    components: /* @__PURE__ */ new Map(),
-    entities: /* @__PURE__ */ new Map(),
-    relations: /* @__PURE__ */ new Map(),
-    rules: /* @__PURE__ */ new Map(),
-    screens: /* @__PURE__ */ new Map(),
-    transitions: /* @__PURE__ */ new Map(),
-    forms: /* @__PURE__ */ new Map(),
-    processFlows: /* @__PURE__ */ new Map(),
-    glossaryTerms: /* @__PURE__ */ new Map(),
-    apiRefs: /* @__PURE__ */ new Map(),
-    tableRefs: /* @__PURE__ */ new Map(),
-    testRefs: /* @__PURE__ */ new Map(),
-    layers: /* @__PURE__ */ new Map(),
-    boundaries: /* @__PURE__ */ new Map(),
-    artifacts: /* @__PURE__ */ new Map()
-  };
-}
-var globalRegistry = createEmptyRegistry();
-function getGlobalRegistry() {
-  return globalRegistry;
-}
-function resetGlobalRegistry() {
-  globalRegistry = createEmptyRegistry();
-}
-function isModelInstance(value) {
-  if (!value || typeof value !== "object") return false;
-  const obj = value;
-  return typeof obj.id === "string" && typeof obj.name === "string" && typeof obj.idPrefix === "string" && obj.schema !== void 0 && typeof obj.validate === "function" && typeof obj.lint === "function";
-}
-function registerExportedModels(module) {
-  for (const [exportName, exportValue] of Object.entries(module)) {
-    if (!exportValue || typeof exportValue !== "object") continue;
-    if (isModelInstance(exportValue)) {
-      registerModel(exportValue);
-      continue;
-    }
-    if (Array.isArray(exportValue)) {
-      registerArrayItems(exportName, exportValue);
-      continue;
-    }
-    const value = exportValue;
-    if (value.components && value.layers && value.boundaries && value.relations) {
-      const arch = value;
-      for (const comp of arch.components) {
-        if (comp.id) globalRegistry.components.set(comp.id, comp);
-      }
-      for (const layer of arch.layers) {
-        if (layer.id) globalRegistry.layers.set(layer.id, layer);
-      }
-      for (const boundary of arch.boundaries) {
-        if (boundary.id) globalRegistry.boundaries.set(boundary.id, boundary);
-      }
-      for (const rel of arch.relations) {
-        if (rel.id) globalRegistry.relations.set(rel.id, rel);
-      }
-      continue;
-    }
-    if (value.entities && value.relations && Array.isArray(value.entities)) {
-      const concept = value;
-      for (const entity of concept.entities) {
-        if (entity.id) globalRegistry.entities.set(entity.id, entity);
-      }
-      for (const rel of concept.relations) {
-        if (rel.id) globalRegistry.relations.set(rel.id, rel);
-      }
-      for (const rule of concept.rules || []) {
-        if (rule.id) globalRegistry.rules.set(rule.id, rule);
-      }
-      continue;
-    }
-    if (value.useCases && value.actors) {
-      const ucModel = value;
-      for (const uc of ucModel.useCases) {
-        if (uc.id) globalRegistry.useCases.set(uc.id, uc);
-      }
-      for (const actor of ucModel.actors) {
-        if (actor.id) globalRegistry.actors.set(actor.id, actor);
-      }
-      continue;
-    }
-    if (value.terms && Array.isArray(value.terms)) {
-      const glossary = value;
-      for (const term of glossary.terms) {
-        if (term.id) globalRegistry.glossaryTerms.set(term.id, term);
-      }
-      continue;
-    }
-    if (value.id && value.title && (value.kind || value.type || value.acceptance)) {
-      globalRegistry.requirements.set(value.id, value);
-      continue;
-    }
-    if (value.id && value.name && value.attributes && Array.isArray(value.attributes)) {
-      globalRegistry.entities.set(value.id, value);
-      continue;
-    }
-    if (value.id && value.name && value.actor && value.mainFlow) {
-      globalRegistry.useCases.set(value.id, value);
-      continue;
-    }
-    if (value.id && value.name && value.type && ["human", "system", "external"].includes(value.type)) {
-      globalRegistry.actors.set(value.id, value);
-      continue;
-    }
-    if (value.id && (value.term || value.abbreviation) && value.definition) {
-      globalRegistry.glossaryTerms.set(value.id, value);
-      continue;
-    }
-  }
-}
-function registerArrayItems(exportName, items) {
-  for (const item of items) {
-    if (!item || typeof item !== "object") continue;
-    const obj = item;
-    if (!obj.id || typeof obj.id !== "string") continue;
-    if (exportName.toLowerCase().includes("requirement") || exportName.toLowerCase().includes("constraints") || obj.type && obj.acceptanceCriteria) {
-      globalRegistry.requirements.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("usecase") || obj.actor && obj.mainFlow) {
-      globalRegistry.useCases.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("actor") || obj.type && ["human", "system", "external"].includes(obj.type) && !obj.mainFlow) {
-      globalRegistry.actors.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("component") || exportName.toLowerCase().includes("container") || obj.type && ["person", "system", "container", "component"].includes(obj.type)) {
-      globalRegistry.components.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("entit") || obj.name && obj.attributes && Array.isArray(obj.attributes)) {
-      globalRegistry.entities.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("term") || exportName.toLowerCase().includes("acronym") || exportName.toLowerCase().includes("glossary") || obj.term && obj.definition) {
-      globalRegistry.glossaryTerms.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("relation") || obj.from && obj.to && obj.label) {
-      globalRegistry.relations.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("layer") || obj.name && typeof obj.order === "number") {
-      globalRegistry.layers.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("boundar") || obj.type && ["system", "context", "container", "deployment"].includes(obj.type) && obj.description) {
-      globalRegistry.boundaries.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("screen") || obj.type && ["page", "modal", "drawer", "panel", "wizard"].includes(obj.type) && obj.auth) {
-      globalRegistry.screens.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("testref") || exportName.toLowerCase().includes("test-ref") || obj.source && obj.verifiesRequirements && Array.isArray(obj.verifiesRequirements)) {
-      globalRegistry.testRefs.set(obj.id, item);
-      continue;
-    }
-    if (exportName.toLowerCase().includes("artifact") || obj.category && obj.location && obj.purpose && ["ssot", "human-readable", "machine-readable", "implementation"].includes(obj.category)) {
-      globalRegistry.artifacts.set(obj.id, item);
-      continue;
-    }
-  }
-}
-async function loadModelsFromDirectory(dirPath, options = {}) {
-  const loadedFiles = [];
-  if (!existsSync(dirPath)) {
-    return loadedFiles;
-  }
-  const entries = readdirSync(dirPath);
-  for (const entry of entries) {
-    const fullPath = join(dirPath, entry);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory() && options.recursive) {
-      const subFiles = await loadModelsFromDirectory(fullPath, options);
-      loadedFiles.push(...subFiles);
-    } else if (stat.isFile()) {
-      const ext = extname(entry);
-      if ([".ts", ".js", ".mts", ".mjs"].includes(ext) && !entry.endsWith(".d.ts")) {
-        if (basename(entry, ext) === "index") {
-          continue;
-        }
-        try {
-          const module = await import(fullPath);
-          loadedFiles.push(fullPath);
-          registerExportedModels(module);
-        } catch (error) {
-          console.error(`Failed to load model from ${fullPath}:`, error);
-        }
-      }
-    }
-  }
-  return loadedFiles;
-}
-async function loadAllModels(config, cwd = process.cwd()) {
-  resetGlobalRegistry();
-  const loadedFiles = [];
-  const errors = [];
-  const designDir = resolve(cwd, config.designDir || "design");
-  const modelDirs = [
-    { path: join(designDir, "requirements") },
-    { path: join(designDir, "usecases") },
-    { path: join(designDir, "architecture") },
-    { path: join(designDir, "data-model") },
-    { path: join(designDir, "screens") },
-    { path: join(designDir, "flows") },
-    { path: join(designDir, "glossary") },
-    // Also load files directly under design/ by default (index.ts, etc.)
-    { path: designDir }
-  ];
-  for (const { path: dirPath } of modelDirs) {
-    if (!existsSync(dirPath)) {
-      continue;
-    }
-    try {
-      const files = await loadModelsFromDirectory(dirPath, { recursive: true });
-      loadedFiles.push(...files);
-    } catch (error) {
-      errors.push({ file: dirPath, error });
-    }
-  }
-  return {
-    registry: getGlobalRegistry(),
-    loadedFiles,
-    errors
-  };
-}
-
-// src/cli/lint.ts
 async function lintCommand(options) {
   console.log(chalk4.blue("speckeeper lint"));
   console.log("");
-  const cwd = process.cwd();
   const config = await loadConfig(options.config);
   console.log(chalk4.gray(`  Design: ${config.designDir || "design"}/`));
   if (options.phase) {
@@ -452,17 +242,12 @@ async function lintCommand(options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry, loadedFiles, errors: loadErrors } = await loadAllModels(config, cwd);
-    if (loadErrors.length > 0) {
-      console.log(chalk4.yellow(`  \u26A0 ${loadErrors.length} file(s) failed to load`));
-      for (const { file, error } of loadErrors) {
-        console.log(chalk4.yellow(`    - ${relative(cwd, file)}: ${error}`));
-      }
-    }
-    console.log(chalk4.gray(`  Loaded: ${loadedFiles.length} files`));
+    registerModelsFromConfig(config.models || []);
+    const models = getAllModels();
+    console.log(chalk4.gray(`  Loaded: ${models.length} models`));
     console.log("");
     console.log(chalk4.blue("  Running lint checks..."));
-    const result = runModelLint(registry, options);
+    const result = runModelLint(options);
     console.log("");
     outputLintResults(result, options);
     if (result.errors > 0) {
@@ -473,11 +258,11 @@ async function lintCommand(options) {
     process.exit(1);
   }
 }
-function runModelLint(registry, options) {
+function runModelLint(options) {
   const issues = [];
   const models = getAllModels();
   for (const model of models) {
-    const specs = getSpecsFromRegistry(registry, model.id);
+    const specs = getSpecs(model.id);
     if (specs.length === 0) continue;
     const lintResults = model.lintAll(specs);
     for (const result of lintResults) {
@@ -503,24 +288,6 @@ function runModelLint(registry, options) {
   }
   return { issues, errors, warnings, infos };
 }
-function getSpecsFromRegistry(registry, modelId) {
-  const registryMap = {
-    "requirement": "requirements",
-    "usecase": "useCases",
-    "actor": "actors",
-    "term": "glossaryTerms",
-    "entity": "entities",
-    "screen": "screens",
-    "process-flow": "processFlows",
-    "component": "components",
-    "boundary": "boundaries",
-    "layer": "layers",
-    "relation": "relations"
-  };
-  const key = registryMap[modelId];
-  if (!key || !registry[key]) return [];
-  return Array.from(registry[key].values());
-}
 function outputLintResults(result, options) {
   if (options.format === "json") {
     console.log(JSON.stringify(result, null, 2));
@@ -557,11 +324,11 @@ async function driftCommand(options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry } = await loadAllModels(config, cwd);
+    registerModelsFromConfig(config.models || []);
     const results = [];
     const models = getAllModels();
     for (const model of models) {
-      const specs = getSpecsFromRegistry2(registry, model.id);
+      const specs = getSpecs(model.id);
       if (specs.length === 0) continue;
       for (const exporter of model.getExporters()) {
         if (exporter.format !== "markdown") continue;
@@ -609,21 +376,6 @@ async function driftCommand(options) {
     process.exit(1);
   }
 }
-function getSpecsFromRegistry2(registry, modelId) {
-  const registryMap = {
-    "requirement": "requirements",
-    "usecase": "useCases",
-    "actor": "actors",
-    "term": "glossaryTerms",
-    "entity": "entities",
-    "screen": "screens",
-    "process-flow": "processFlows",
-    "component": "components"
-  };
-  const key = registryMap[modelId];
-  if (!key || !registry[key]) return [];
-  return Array.from(registry[key].values());
-}
 function normalizeContent(content) {
   return content.trim().replace(/\r\n/g, "\n");
 }
@@ -663,14 +415,14 @@ async function checkCommand(type, options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry } = await loadAllModels(config, cwd);
+    registerModelsFromConfig(config.models || []);
     const results = [];
     const models = getAllModels();
     if (options.verbose) {
       console.log(chalk4.gray(`  Registered models: ${models.map((m) => m.id).join(", ")}`));
     }
     for (const model of models) {
-      const specs = getSpecsFromRegistry3(registry, model.id);
+      const specs = getSpecs(model.id);
       if (specs.length === 0) continue;
       for (const spec of specs) {
         const sourcePath = model.getExternalSourcePath(spec);
@@ -706,7 +458,7 @@ async function checkCommand(type, options) {
     if (options.coverage) {
       console.log("");
       console.log(chalk4.blue("  Coverage checks..."));
-      const coverageResults = runAllCoverageChecks(registry);
+      const coverageResults = runAllCoverageChecks();
       if (coverageResults.length > 0) {
         outputAllCoverageResults(coverageResults);
         for (const check of coverageResults) {
@@ -745,25 +497,6 @@ async function checkCommand(type, options) {
     process.exit(1);
   }
 }
-function getSpecsFromRegistry3(registry, modelId) {
-  const registryMap = {
-    "requirement": "requirements",
-    "usecase": "useCases",
-    "actor": "actors",
-    "term": "glossaryTerms",
-    "entity": "entities",
-    "screen": "screens",
-    "process-flow": "processFlows",
-    "component": "components",
-    "api-ref": "apiRefs",
-    "table-ref": "tableRefs",
-    "test-ref": "testRefs",
-    "artifact": "artifacts"
-  };
-  const key = registryMap[modelId];
-  if (!key || !registry[key]) return [];
-  return Array.from(registry[key].values());
-}
 function loadExternalData(filePath) {
   const content = readFileSync(filePath, "utf-8");
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
@@ -795,20 +528,15 @@ function outputCheckResults(results) {
   console.log("");
   console.log(chalk4.gray(`  Summary: ${totalErrors} errors, ${totalWarnings} warnings`));
 }
-function runAllCoverageChecks(registry) {
+function runAllCoverageChecks() {
   const models = getAllModels();
   const results = [];
-  const registryRecord = {};
-  for (const [key, value] of Object.entries(registry)) {
-    if (value instanceof Map) {
-      registryRecord[key] = value;
-    }
-  }
+  const registry = Object.fromEntries(getSpecStore());
   for (const model of models) {
     const checker = model.getCoverageChecker();
     if (checker) {
-      const specs = getSpecsFromRegistry3(registry, model.id);
-      const result = model.checkCoverage(specs, registryRecord);
+      const specs = getSpecs(model.id);
+      const result = model.checkCoverage(specs, registry);
       if (result) {
         results.push({
           modelId: model.id,
@@ -918,7 +646,6 @@ async function impactCommand(targetId, options) {
     console.log(chalk4.gray("  Usage: speckeeper impact <id>"));
     process.exit(1);
   }
-  const cwd = process.cwd();
   const config = await loadConfig(options.config);
   const maxDepth = options.depth ? parseInt(options.depth, 10) : 3;
   console.log(chalk4.gray(`  Target: ${targetId}`));
@@ -926,35 +653,27 @@ async function impactCommand(targetId, options) {
   console.log("");
   try {
     console.log(chalk4.blue("  Loading models..."));
-    const { registry } = await loadAllModels(config, cwd);
-    const target = findById(registry, targetId);
-    if (!target) {
+    registerModelsFromConfig(config.models || []);
+    const store = getSpecStore();
+    const targetType = findModelTypeBySpecId(targetId);
+    if (!targetType) {
       console.error(chalk4.red(`  Error: Target '${targetId}' not found`));
       process.exit(1);
     }
     console.log(chalk4.blue("  Analyzing impact..."));
-    const result = analyzeImpact(registry, targetId, target.type, maxDepth);
+    const result = analyzeImpact(store, targetId, targetType, maxDepth);
     outputImpactResults(result, options);
   } catch (error) {
     console.error(chalk4.red("Impact analysis failed:"), error);
     process.exit(1);
   }
 }
-function findById(registry, id) {
-  for (const [type, map] of Object.entries(registry)) {
-    if (map instanceof Map && map.has(id)) {
-      return { type, data: map.get(id) };
-    }
-  }
-  return null;
-}
-function analyzeImpact(registry, targetId, targetType, maxDepth) {
+function analyzeImpact(store, targetId, targetType, maxDepth) {
   const impactedNodes = [];
   const visited = /* @__PURE__ */ new Set([targetId]);
   function findReferences(id, depth) {
     if (depth > maxDepth) return;
-    for (const [type, map] of Object.entries(registry)) {
-      if (!(map instanceof Map)) continue;
+    for (const [type, map] of store) {
       for (const [itemId, item] of map) {
         if (visited.has(itemId)) continue;
         const itemStr = JSON.stringify(item);
@@ -1095,6 +814,1690 @@ function copyTemplateDir(srcDir, destDir, projectName, force, onFile, relativePa
   }
 }
 
+// src/scaffold/mermaid-parser.ts
+function extractMermaidBlocks(markdown) {
+  const blocks = [];
+  const regex = /```mermaid\s*\n([\s\S]*?)```/g;
+  let match;
+  while ((match = regex.exec(markdown)) !== null) {
+    blocks.push(match[1]);
+  }
+  return blocks;
+}
+function parseFlowchart(mermaidSource) {
+  const lines = mermaidSource.split("\n");
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const classDefs = [];
+  const classAssignments = [];
+  let direction = "TB";
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("%%")) continue;
+    const flowchartMatch = line.match(/^flowchart\s+(\w+)/);
+    if (flowchartMatch) {
+      direction = flowchartMatch[1];
+      continue;
+    }
+    if (line.startsWith("graph ")) {
+      const gMatch = line.match(/^graph\s+(\w+)/);
+      if (gMatch) direction = gMatch[1];
+      continue;
+    }
+    const classDefMatch = line.match(/^classDef\s+(\S+)\s+(.*)/);
+    if (classDefMatch) {
+      classDefs.push({ name: classDefMatch[1], styles: classDefMatch[2] });
+      continue;
+    }
+    const classAssignMatch = line.match(/^class\s+(\S+)\s+(\S+)/);
+    if (classAssignMatch) {
+      const nodeIds = classAssignMatch[1].split(",").map((s) => s.trim());
+      classAssignments.push({ nodeIds, className: classAssignMatch[2] });
+      for (const id of nodeIds) {
+        ensureNode(nodes, id);
+        const node = nodes.get(id);
+        if (!node.classes.includes(classAssignMatch[2])) {
+          node.classes.push(classAssignMatch[2]);
+        }
+      }
+      continue;
+    }
+    const edgeParsed = tryParseEdgeLine(line);
+    if (edgeParsed) {
+      for (const { sourceId, sourceLabel, targetId, targetLabel, label, direction: dir } of edgeParsed) {
+        ensureNode(nodes, sourceId, sourceLabel);
+        ensureNode(nodes, targetId, targetLabel);
+        edges.push({
+          sourceId,
+          targetId,
+          rawLabel: label,
+          direction: dir
+        });
+      }
+      continue;
+    }
+    const standaloneNode = tryParseStandaloneNode(line);
+    if (standaloneNode) {
+      ensureNode(nodes, standaloneNode.id, standaloneNode.label);
+    }
+  }
+  return { direction, nodes, edges, classDefs, classAssignments };
+}
+function parseMarkdownFlowchart(markdown) {
+  const blocks = extractMermaidBlocks(markdown);
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (trimmed.startsWith("flowchart") || trimmed.startsWith("graph")) {
+      return parseFlowchart(trimmed);
+    }
+  }
+  return null;
+}
+function ensureNode(nodes, id, label) {
+  const existing = nodes.get(id);
+  if (existing) {
+    if (label && !existing.label) {
+      existing.label = label;
+    }
+  } else {
+    nodes.set(id, { id, label, classes: [] });
+  }
+}
+var NODE_PATTERN = /([A-Za-z_]\w*)(?:\[([^\]]*)\])?/;
+function tryParseEdgeLine(line) {
+  const arrowPatterns = [
+    { regex: /<-{2,}>/, direction: "bidirectional" },
+    { regex: /<={2,}>/, direction: "bidirectional" },
+    { regex: /-{2,}>/, direction: "forward" },
+    { regex: /={2,}>/, direction: "forward" },
+    { regex: /-\.->/, direction: "forward" }
+  ];
+  let bestMatch = null;
+  for (const ap of arrowPatterns) {
+    const m = line.match(ap.regex);
+    if (m && m.index !== void 0) {
+      if (!bestMatch || m.index < bestMatch.index) {
+        bestMatch = { index: m.index, length: m[0].length, direction: ap.direction };
+      }
+    }
+  }
+  if (!bestMatch) return null;
+  const leftPart = line.substring(0, bestMatch.index).trim();
+  const rightPart = line.substring(bestMatch.index + bestMatch.length).trim();
+  const sourceMatch = leftPart.match(NODE_PATTERN);
+  if (!sourceMatch) return null;
+  const sourceId = sourceMatch[1];
+  const sourceLabel = sourceMatch[2] || void 0;
+  let label;
+  let targetStr = rightPart;
+  const labelMatch = rightPart.match(/^\|([^|]*)\|\s*(.*)/);
+  if (labelMatch) {
+    label = labelMatch[1].trim();
+    targetStr = labelMatch[2];
+  }
+  const targetMatch = targetStr.match(NODE_PATTERN);
+  if (!targetMatch) return null;
+  const targetId = targetMatch[1];
+  const targetLabel = targetMatch[2] || void 0;
+  return [{
+    sourceId,
+    sourceLabel,
+    targetId,
+    targetLabel,
+    label,
+    direction: bestMatch.direction
+  }];
+}
+function tryParseStandaloneNode(line) {
+  const m = line.match(/^([A-Za-z_]\w*)\[([^\]]*)\]\s*$/);
+  if (m) {
+    return { id: m[1], label: m[2] };
+  }
+  return null;
+}
+
+// src/scaffold/edge-vocabulary.ts
+var EDGE_VOCABULARY = [
+  // A. lint targets (speckeeper ↔ speckeeper reference integrity)
+  {
+    label: "refines",
+    expectedDirection: "forward",
+    relationType: "refines",
+    category: "lint",
+    description: "Decompose higher-level item into lower-level detail"
+  },
+  {
+    label: "relatedTo",
+    expectedDirection: "bidirectional",
+    relationType: "relatedTo",
+    category: "lint",
+    description: "Bidirectional association or consistency constraint"
+  },
+  {
+    label: "uses",
+    expectedDirection: "forward",
+    relationType: "uses",
+    category: "lint",
+    description: "Reference / dependency"
+  },
+  // B. check targets (speckeeper → external SSOT)
+  {
+    label: "implements",
+    expectedDirection: "forward",
+    relationType: "implements",
+    category: "check",
+    description: "Realize speckeeper spec as external artifact, interface, or test"
+  },
+  // C. coverage targets
+  {
+    label: "includes",
+    expectedDirection: "forward",
+    relationType: "includes",
+    category: "coverage",
+    description: "Parent contains child items"
+  },
+  {
+    label: "traces",
+    expectedDirection: "forward",
+    relationType: "traces",
+    category: "coverage",
+    description: "Derive target from source"
+  },
+  {
+    label: "verifies",
+    expectedDirection: "forward",
+    relationType: "verifies",
+    category: "coverage",
+    description: "Test verifies target"
+  },
+  // Additional RELATION_TYPES (usable but no special scaffold behaviour)
+  {
+    label: "dependsOn",
+    expectedDirection: "forward",
+    relationType: "dependsOn",
+    category: "lint",
+    description: "Dependency relationship"
+  },
+  {
+    label: "satisfies",
+    expectedDirection: "forward",
+    relationType: "satisfies",
+    category: "lint",
+    description: "Satisfies business/requirements"
+  }
+];
+var EXTERNAL_LABELS = [
+  {
+    label: "generate",
+    expectedDirection: "forward",
+    relationType: void 0,
+    category: "drift",
+    description: "Automated generation (external tool)"
+  },
+  {
+    label: "apply",
+    expectedDirection: "forward",
+    relationType: void 0,
+    category: "external",
+    description: "Apply to external system"
+  },
+  {
+    label: "deploy",
+    expectedDirection: "forward",
+    relationType: void 0,
+    category: "external",
+    description: "Deploy artifact"
+  }
+];
+var ALL_VOCABULARY = [...EDGE_VOCABULARY, ...EXTERNAL_LABELS];
+var SORTED_VOCABULARY = [...ALL_VOCABULARY].sort(
+  (a, b) => b.label.length - a.label.length
+);
+var SORTED_SPECKEEPER_VOCABULARY = [...EDGE_VOCABULARY].sort(
+  (a, b) => b.label.length - a.label.length
+);
+function normalizeLabel(rawLabel, vocabulary = SORTED_VOCABULARY) {
+  if (!rawLabel) return null;
+  const lower = rawLabel.toLowerCase().trim();
+  for (const entry of vocabulary) {
+    if (lower === entry.label.toLowerCase()) {
+      return { entry, modifier: void 0 };
+    }
+  }
+  for (const entry of vocabulary) {
+    const entryLower = entry.label.toLowerCase();
+    if (lower.endsWith(entryLower)) {
+      const mod = rawLabel.slice(0, rawLabel.length - entry.label.length).trim();
+      return { entry, modifier: mod || void 0 };
+    }
+  }
+  for (const entry of vocabulary) {
+    const entryLower = entry.label.toLowerCase();
+    if (lower.includes(entryLower)) {
+      const idx = lower.indexOf(entryLower);
+      const before = rawLabel.slice(0, idx).trim();
+      const after = rawLabel.slice(idx + entry.label.length).trim();
+      const mod = [before, after].filter(Boolean).join(" ");
+      return { entry, modifier: mod || void 0 };
+    }
+  }
+  return null;
+}
+function resolveEdges(edges, nodes, speckeeperClassName) {
+  const diagnostics = [];
+  const resolved = [];
+  const isSpk = (id) => nodes.get(id)?.classes.includes(speckeeperClassName) ?? false;
+  const fallback = EDGE_VOCABULARY.find((v) => v.label === "relatedTo");
+  for (const edge of edges) {
+    const involvesSpeckeeper = isSpk(edge.sourceId) || isSpk(edge.targetId);
+    const norm = normalizeLabel(edge.rawLabel);
+    if (!norm) {
+      if (involvesSpeckeeper) {
+        diagnostics.push({
+          severity: "warning",
+          message: `Edge label "${edge.rawLabel}" is not a valid speckeeper RelationType \u2014 falling back to "relatedTo"`,
+          context: `${edge.sourceId} \u2192 ${edge.targetId}`
+        });
+        resolved.push({
+          ...edge,
+          normalizedLabel: "relatedTo",
+          vocabulary: fallback,
+          modifier: void 0
+        });
+      } else {
+        resolved.push({
+          ...edge,
+          normalizedLabel: edge.rawLabel ?? "",
+          vocabulary: { label: edge.rawLabel ?? "", expectedDirection: "forward", relationType: void 0, category: "external", description: "" },
+          modifier: void 0
+        });
+      }
+      continue;
+    }
+    if (involvesSpeckeeper && !norm.entry.relationType) {
+      const spkNorm = normalizeLabel(edge.rawLabel, SORTED_SPECKEEPER_VOCABULARY);
+      if (!spkNorm) {
+        diagnostics.push({
+          severity: "warning",
+          message: `Edge label "${edge.rawLabel}" is not a valid speckeeper RelationType \u2014 falling back to "relatedTo"`,
+          context: `${edge.sourceId} \u2192 ${edge.targetId}`
+        });
+        resolved.push({
+          ...edge,
+          normalizedLabel: "relatedTo",
+          vocabulary: fallback,
+          modifier: void 0
+        });
+        continue;
+      }
+    }
+    resolved.push({
+      ...edge,
+      normalizedLabel: norm.entry.label,
+      vocabulary: norm.entry,
+      modifier: norm.modifier
+    });
+    if (involvesSpeckeeper && edge.direction !== norm.entry.expectedDirection) {
+      const expected = norm.entry.expectedDirection === "bidirectional" ? "<-->" : "-->";
+      diagnostics.push({
+        severity: "warning",
+        message: `"${norm.entry.label}" expects ${expected} arrow but got ${edge.direction === "bidirectional" ? "<-->" : "-->"}`,
+        context: `${edge.sourceId} \u2192 ${edge.targetId}`
+      });
+    }
+    if (norm.entry.label === "implements") {
+      if (isSpk(edge.sourceId) && isSpk(edge.targetId)) {
+        diagnostics.push({
+          severity: "warning",
+          message: '"implements" should be speckeeper \u2192 external; consider using "refines" for speckeeper \u2192 speckeeper edges',
+          context: `${edge.sourceId} \u2192 ${edge.targetId}`
+        });
+      }
+    }
+    if (norm.entry.label === "includes" || norm.entry.label === "traces") {
+      if (!isSpk(edge.sourceId) || !isSpk(edge.targetId)) {
+        diagnostics.push({
+          severity: "warning",
+          message: `"${norm.entry.label}" should connect two speckeeper-managed nodes`,
+          context: `${edge.sourceId} \u2192 ${edge.targetId}`
+        });
+      }
+    }
+  }
+  return { resolved, diagnostics };
+}
+function isCheckEdge(entry) {
+  return entry.category === "check";
+}
+
+// src/scaffold/template-registry.ts
+var NODE_ALIAS = {
+  // L0
+  TERM: "term",
+  CDM: "entity",
+  // L1
+  SR: "requirement",
+  FR: "requirement",
+  NFR: "requirement",
+  UC: "usecase",
+  // L2
+  LDM: "logical-entity",
+  AT: "acceptance-test",
+  DT: "data-test",
+  VC: "validation-constraint"
+};
+var TEMPLATE_META = {
+  term: { level: "L0", fileName: "term", primaryTypeName: "Term" },
+  entity: { level: "L0", fileName: "entity", primaryTypeName: "Entity" },
+  requirement: { level: "L1", fileName: "requirement", primaryTypeName: "Requirement" },
+  usecase: { level: "L1", fileName: "usecase", primaryTypeName: "UseCase" },
+  "logical-entity": { level: "L2", fileName: "logical-entity", primaryTypeName: "LogicalEntity" },
+  "acceptance-test": { level: "L2", fileName: "acceptance-test", primaryTypeName: "AcceptanceTest" },
+  "data-test": { level: "L2", fileName: "data-test", primaryTypeName: "DataTest" },
+  "validation-constraint": { level: "L2", fileName: "validation-constraint", primaryTypeName: "ValidationConstraint" }
+};
+function resolveModelTemplate(nodeId) {
+  const templateName = NODE_ALIAS[nodeId];
+  if (templateName) {
+    const meta = TEMPLATE_META[templateName];
+    return {
+      templateName,
+      defaultLevel: meta.level,
+      defaultIdPrefix: nodeId,
+      modelName: meta.primaryTypeName,
+      fileName: meta.fileName
+    };
+  }
+  return {
+    templateName: "base",
+    defaultLevel: "L1",
+    defaultIdPrefix: nodeId,
+    modelName: toPascalCase(nodeId),
+    fileName: toKebabCase(nodeId)
+  };
+}
+var CHECKER_ALIAS = {
+  DDL: {
+    templateName: "ddl-checker",
+    targetType: "ddl",
+    fileName: "ddl-checker"
+  },
+  API: {
+    templateName: "openapi-checker",
+    targetType: "openapi",
+    fileName: "openapi-checker"
+  },
+  E2ET: {
+    templateName: "test-checker",
+    targetType: "test",
+    fileName: "e2e-test-checker"
+  },
+  UT: {
+    templateName: "test-checker",
+    targetType: "test",
+    fileName: "unit-test-checker"
+  },
+  DUT: {
+    templateName: "test-checker",
+    targetType: "test",
+    fileName: "data-unit-test-checker"
+  },
+  IT: {
+    templateName: "test-checker",
+    targetType: "test",
+    fileName: "integration-test-checker"
+  }
+};
+function resolveCheckerTemplate(targetNodeId) {
+  return CHECKER_ALIAS[targetNodeId];
+}
+function toPascalCase(s) {
+  return s.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function toKebabCase(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+
+// src/scaffold/templates/requirement.ts
+function generateRequirementModel(_params) {
+  return `/**
+ * Requirement Model Definitions
+ *
+ * Contains SystemRequirement (SR), FunctionalRequirement (FR),
+ * and NonFunctionalRequirement (NFR) models sharing the same schema.
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const AcceptanceCriteriaSchema = z.object({
+  id: z.string(),
+  description: z.string(),
+  verificationMethod: z.enum(['test', 'review', 'demo', 'inspection']).optional(),
+});
+
+export const RequirementSchema = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  description: z.string(),
+  type: z.enum(['functional', 'non-functional', 'constraint']),
+  priority: z.enum(['must', 'should', 'could']),
+  rationale: z.string().optional(),
+  acceptanceCriteria: z.array(AcceptanceCriteriaSchema).min(1),
+  category: z.string().optional(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type AcceptanceCriteria = z.infer<typeof AcceptanceCriteriaSchema>;
+export type Requirement = z.input<typeof RequirementSchema>;
+
+// =============================================================================
+// Shared lint rules and exporters
+// =============================================================================
+
+const requirementLintRules: LintRule<Requirement>[] = [
+  {
+    id: 'req-acceptance-not-empty',
+    severity: 'error',
+    message: 'Requirement must have at least one acceptance criteria',
+    check: (spec) => !spec.acceptanceCriteria || spec.acceptanceCriteria.length === 0,
+  },
+  {
+    id: 'req-acceptance-id-format',
+    severity: 'warning',
+    message: 'Acceptance criteria ID should follow parent requirement ID (e.g., FR-001-01)',
+    check: (spec) => {
+      if (!spec.acceptanceCriteria) return false;
+      return spec.acceptanceCriteria.some(ac => !ac.id.startsWith(spec.id + '-'));
+    },
+  },
+];
+
+const requirementExporters: Exporter<Requirement>[] = [
+  {
+    format: 'markdown',
+    single: (spec) => {
+      const lines: string[] = [];
+      lines.push(\`# \${spec.name}\`);
+      lines.push('');
+      lines.push(\`**ID**: \${spec.id}\`);
+      lines.push(\`**Type**: \${spec.type}\`);
+      lines.push(\`**Priority**: \${spec.priority}\`);
+      lines.push('');
+      lines.push('## Description');
+      lines.push('');
+      lines.push(spec.description);
+      lines.push('');
+      lines.push('## Acceptance Criteria');
+      lines.push('');
+      for (const ac of spec.acceptanceCriteria) {
+        lines.push(\`- **\${ac.id}**: \${ac.description}\`);
+      }
+      return lines.join('\\n');
+    },
+    outputDir: 'requirements',
+    filename: (spec) => spec.id,
+  },
+];
+
+// =============================================================================
+// Model Classes
+// =============================================================================
+
+class SystemRequirementModel extends Model<typeof RequirementSchema> {
+  readonly id = 'system-requirement';
+  readonly name = 'SystemRequirement';
+  readonly idPrefix = 'SR';
+  readonly schema = RequirementSchema;
+  readonly description = 'Defines system-level requirements';
+  protected modelLevel: ModelLevel = 'L1';
+  protected lintRules = requirementLintRules;
+  protected exporters = requirementExporters;
+}
+
+class FunctionalRequirementModel extends Model<typeof RequirementSchema> {
+  readonly id = 'functional-requirement';
+  readonly name = 'FunctionalRequirement';
+  readonly idPrefix = 'FR';
+  readonly schema = RequirementSchema;
+  readonly description = 'Defines functional requirements';
+  protected modelLevel: ModelLevel = 'L1';
+  protected lintRules = requirementLintRules;
+  protected exporters = requirementExporters;
+}
+
+class NonFunctionalRequirementModel extends Model<typeof RequirementSchema> {
+  readonly id = 'non-functional-requirement';
+  readonly name = 'NonFunctionalRequirement';
+  readonly idPrefix = 'NFR';
+  readonly schema = RequirementSchema;
+  readonly description = 'Defines non-functional requirements and constraints';
+  protected modelLevel: ModelLevel = 'L1';
+  protected lintRules = requirementLintRules;
+  protected exporters = requirementExporters;
+}
+
+export { SystemRequirementModel, FunctionalRequirementModel, NonFunctionalRequirementModel };
+`;
+}
+
+// src/scaffold/templates/usecase.ts
+function generateUseCaseModel(_params) {
+  return `/**
+ * UseCase Model Definition
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const ActorSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  type: z.enum(['human', 'system', 'external']),
+  relations: z.array(RelationSchema).optional(),
+});
+
+export const UseCaseStepSchema = z.object({
+  stepNumber: z.number(),
+  type: z.enum(['user_action', 'system_response', 'alternative']),
+  description: z.string(),
+});
+
+export const UseCaseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  actor: z.string(),
+  preconditions: z.array(z.string()).optional().default([]),
+  postconditions: z.array(z.string()).optional().default([]),
+  mainFlow: z.array(UseCaseStepSchema),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type Actor = z.input<typeof ActorSchema>;
+export type UseCaseStep = z.infer<typeof UseCaseStepSchema>;
+export type UseCase = z.input<typeof UseCaseSchema>;
+
+// =============================================================================
+// Actor Model Class
+// =============================================================================
+
+class ActorModel extends Model<typeof ActorSchema> {
+  readonly id = 'actor';
+  readonly name = 'Actor';
+  readonly idPrefix = 'ACT';
+  readonly schema = ActorSchema;
+  readonly description = 'Defines actors';
+  protected modelLevel: ModelLevel = 'L0';
+
+  protected lintRules: LintRule<Actor>[] = [
+    {
+      id: 'actor-has-description',
+      severity: 'warning',
+      message: 'Actor should have a description',
+      check: (spec) => !spec.description || spec.description.trim() === '',
+    },
+  ];
+
+  protected exporters: Exporter<Actor>[] = [];
+}
+
+// =============================================================================
+// UseCase Model Class
+// =============================================================================
+
+class UseCaseModel extends Model<typeof UseCaseSchema> {
+  readonly id = 'usecase';
+  readonly name = 'UseCase';
+  readonly idPrefix = 'UC';
+  readonly schema = UseCaseSchema;
+  readonly description = 'Defines use cases (business flows)';
+  protected modelLevel: ModelLevel = 'L1';
+
+  protected lintRules: LintRule<UseCase>[] = [
+    {
+      id: 'usecase-has-main-flow',
+      severity: 'error',
+      message: 'UseCase must have a main flow',
+      check: (spec) => !spec.mainFlow || spec.mainFlow.length === 0,
+    },
+    {
+      id: 'usecase-has-actor',
+      severity: 'error',
+      message: 'UseCase must have an actor',
+      check: (spec) => !spec.actor || spec.actor.trim() === '',
+    },
+  ];
+
+  protected exporters: Exporter<UseCase>[] = [];
+}
+
+export { ActorModel, UseCaseModel };
+`;
+}
+
+// src/scaffold/templates/term.ts
+function generateTermModel(_params) {
+  return `/**
+ * Term Model Definition
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const TermSchema = z.object({
+  id: z.string(),
+  term: z.string(),
+  definition: z.string(),
+  category: z.enum(['business', 'technical', 'acronym', 'process', 'role']),
+  abbreviation: z.string().optional(),
+  expandedForm: z.string().optional(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type Term = z.input<typeof TermSchema>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class TermModel extends Model<typeof TermSchema> {
+  readonly id = 'term';
+  readonly name = 'Term';
+  readonly idPrefix = 'TERM';
+  readonly schema = TermSchema;
+  readonly description = 'Defines terms (glossary)';
+  protected modelLevel: ModelLevel = 'L0';
+
+  protected lintRules: LintRule<Term>[] = [
+    {
+      id: 'term-has-definition',
+      severity: 'error',
+      message: 'Term must have a definition',
+      check: (spec) => !spec.definition || spec.definition.trim() === '',
+    },
+    {
+      id: 'term-acronym-has-expanded-form',
+      severity: 'warning',
+      message: 'Acronym terms should have an expanded form',
+      check: (spec) => spec.category === 'acronym' && !spec.expandedForm,
+    },
+  ];
+
+  protected exporters: Exporter<Term>[] = [];
+}
+
+export { TermModel };
+`;
+}
+
+// src/scaffold/templates/entity.ts
+function generateEntityModel(_params) {
+  return `/**
+ * Entity Model Definition (Conceptual Data Model)
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const AttributeSchema = z.object({
+  name: z.string(),
+  type: z.enum(['string', 'number', 'boolean', 'date', 'datetime', 'uuid', 'enum', 'reference']),
+  required: z.boolean().optional().default(true),
+  description: z.string().optional(),
+});
+
+export const EntitySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  attributes: z.array(AttributeSchema),
+  isAggregateRoot: z.boolean().optional().default(false),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type Attribute = z.infer<typeof AttributeSchema>;
+export type Entity = z.input<typeof EntitySchema>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class ConceptualDataModel extends Model<typeof EntitySchema> {
+  readonly id = 'conceptual-data-model';
+  readonly name = 'ConceptualDataModel';
+  readonly idPrefix = 'CDM';
+  readonly schema = EntitySchema;
+  readonly description = 'Defines conceptual entities (domain model)';
+  protected modelLevel: ModelLevel = 'L0';
+
+  protected lintRules: LintRule<Entity>[] = [
+    {
+      id: 'entity-has-attributes',
+      severity: 'warning',
+      message: 'Entity should have at least one attribute',
+      check: (spec) => !spec.attributes || spec.attributes.length === 0,
+    },
+  ];
+
+  protected exporters: Exporter<Entity>[] = [
+    {
+      format: 'markdown',
+      single: (spec) => {
+        const lines: string[] = [];
+        lines.push(\`# \${spec.name}\`);
+        lines.push('');
+        lines.push(\`**ID**: \${spec.id}\`);
+        lines.push('');
+        lines.push(spec.description);
+        lines.push('');
+        lines.push('## Attributes');
+        lines.push('');
+        lines.push('| Name | Type | Required | Description |');
+        lines.push('|------|------|----------|-------------|');
+        for (const attr of spec.attributes) {
+          lines.push(\`| \${attr.name} | \${attr.type} | \${attr.required ? 'Yes' : 'No'} | \${attr.description || ''} |\`);
+        }
+        return lines.join('\\n');
+      },
+      outputDir: 'data-model',
+      filename: (spec) => spec.id,
+    },
+  ];
+}
+
+export { ConceptualDataModel };
+`;
+}
+
+// src/scaffold/templates/logical-entity.ts
+function generateLogicalEntityModel(_params) {
+  return `/**
+ * LogicalEntity Model Definition (Logical Data Model)
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const ColumnSchema = z.object({
+  name: z.string(),
+  dataType: z.string(),
+  nullable: z.boolean().optional().default(false),
+  primaryKey: z.boolean().optional().default(false),
+  foreignKey: z.object({
+    table: z.string(),
+    column: z.string(),
+  }).optional(),
+  description: z.string().optional(),
+});
+
+export const ConstraintSchema = z.object({
+  name: z.string(),
+  type: z.enum(['unique', 'check', 'foreign_key', 'index']),
+  columns: z.array(z.string()),
+  expression: z.string().optional(),
+});
+
+export const LogicalEntitySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  tableName: z.string(),
+  columns: z.array(ColumnSchema).min(1),
+  constraints: z.array(ConstraintSchema).optional(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type Column = z.infer<typeof ColumnSchema>;
+export type Constraint = z.infer<typeof ConstraintSchema>;
+export type LogicalEntity = z.input<typeof LogicalEntitySchema>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class LogicalDataModel extends Model<typeof LogicalEntitySchema> {
+  readonly id = 'logical-data-model';
+  readonly name = 'LogicalDataModel';
+  readonly idPrefix = 'LDM';
+  readonly schema = LogicalEntitySchema;
+  readonly description = 'Defines logical data model entities (tables, columns, constraints)';
+  protected modelLevel: ModelLevel = 'L2';
+
+  protected lintRules: LintRule<LogicalEntity>[] = [
+    {
+      id: 'lent-has-columns',
+      severity: 'error',
+      message: 'LogicalEntity must have at least one column',
+      check: (spec) => !spec.columns || spec.columns.length === 0,
+    },
+    {
+      id: 'lent-has-primary-key',
+      severity: 'warning',
+      message: 'LogicalEntity should have at least one primary key column',
+      check: (spec) => {
+        if (!spec.columns) return true;
+        return !spec.columns.some(c => c.primaryKey);
+      },
+    },
+  ];
+
+  protected exporters: Exporter<LogicalEntity>[] = [
+    {
+      format: 'markdown',
+      single: (spec) => {
+        const lines: string[] = [];
+        lines.push(\`# \${spec.name}\`);
+        lines.push('');
+        lines.push(\`**ID**: \${spec.id}  \`);
+        lines.push(\`**Table**: \${spec.tableName}\`);
+        lines.push('');
+        lines.push(spec.description);
+        lines.push('');
+        lines.push('## Columns');
+        lines.push('');
+        lines.push('| Name | Type | Nullable | PK | Description |');
+        lines.push('|------|------|----------|----|-------------|');
+        for (const col of spec.columns) {
+          lines.push(\`| \${col.name} | \${col.dataType} | \${col.nullable ? 'Yes' : 'No'} | \${col.primaryKey ? 'Yes' : ''} | \${col.description || ''} |\`);
+        }
+        return lines.join('\\n');
+      },
+      outputDir: 'data-model',
+      filename: (spec) => spec.id,
+    },
+  ];
+}
+
+export { LogicalDataModel };
+`;
+}
+
+// src/scaffold/templates/acceptance-test.ts
+function generateAcceptanceTestModel(_params) {
+  return `/**
+ * AcceptanceTest Model Definition
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const TestStepSchema = z.object({
+  stepNumber: z.number(),
+  action: z.string(),
+  expectedResult: z.string(),
+});
+
+export const AcceptanceTestSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  targetId: z.string(),
+  testType: z.enum(['e2e', 'manual', 'review']),
+  steps: z.array(TestStepSchema).optional(),
+  expectedResult: z.string(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type TestStep = z.infer<typeof TestStepSchema>;
+export type AcceptanceTest = z.input<typeof AcceptanceTestSchema>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class AcceptanceTestModel extends Model<typeof AcceptanceTestSchema> {
+  readonly id = 'acceptance-test';
+  readonly name = 'AcceptanceTest';
+  readonly idPrefix = 'AT';
+  readonly schema = AcceptanceTestSchema;
+  readonly description = 'Defines acceptance test specifications';
+  protected modelLevel: ModelLevel = 'L2';
+
+  protected lintRules: LintRule<AcceptanceTest>[] = [
+    {
+      id: 'at-has-target',
+      severity: 'error',
+      message: 'AcceptanceTest must reference a target requirement or use case',
+      check: (spec) => !spec.targetId || spec.targetId.trim() === '',
+    },
+  ];
+
+  protected exporters: Exporter<AcceptanceTest>[] = [];
+}
+
+export { AcceptanceTestModel };
+`;
+}
+
+// src/scaffold/templates/data-test.ts
+function generateDataTestModel(_params) {
+  return `/**
+ * DataTest Model Definition
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const DataTestSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  targetEntityId: z.string(),
+  ruleType: z.enum(['fk', 'unique', 'type', 'not-null']),
+  condition: z.string(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type DataTest = z.input<typeof DataTestSchema>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class DataTestModel extends Model<typeof DataTestSchema> {
+  readonly id = 'data-test';
+  readonly name = 'DataTest';
+  readonly idPrefix = 'DT';
+  readonly schema = DataTestSchema;
+  readonly description = 'Defines data integrity test specifications';
+  protected modelLevel: ModelLevel = 'L2';
+
+  protected lintRules: LintRule<DataTest>[] = [
+    {
+      id: 'dt-has-target-entity',
+      severity: 'error',
+      message: 'DataTest must reference a target entity',
+      check: (spec) => !spec.targetEntityId || spec.targetEntityId.trim() === '',
+    },
+  ];
+
+  protected exporters: Exporter<DataTest>[] = [];
+}
+
+export { DataTestModel };
+`;
+}
+
+// src/scaffold/templates/validation-constraint.ts
+function generateValidationConstraintModel(_params) {
+  return `/**
+ * ValidationConstraint Model Definition
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const ValidationConstraintSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  targetField: z.string(),
+  constraintType: z.enum(['range', 'format', 'required', 'enum', 'custom']),
+  rule: z.string(),
+  errorMessage: z.string().optional(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type ValidationConstraint = z.input<typeof ValidationConstraintSchema>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class ValidationConstraintModel extends Model<typeof ValidationConstraintSchema> {
+  readonly id = 'validation-constraint';
+  readonly name = 'ValidationConstraint';
+  readonly idPrefix = 'VC';
+  readonly schema = ValidationConstraintSchema;
+  readonly description = 'Defines validation constraints (input rules, boundary values, formats)';
+  protected modelLevel: ModelLevel = 'L2';
+
+  protected lintRules: LintRule<ValidationConstraint>[] = [
+    {
+      id: 'vc-has-rule',
+      severity: 'error',
+      message: 'ValidationConstraint must have a rule definition',
+      check: (spec) => !spec.rule || spec.rule.trim() === '',
+    },
+  ];
+
+  protected exporters: Exporter<ValidationConstraint>[] = [];
+}
+
+export { ValidationConstraintModel };
+`;
+}
+
+// src/scaffold/templates/base.ts
+function generateBaseModel(params) {
+  const schemaName = `${params.modelName}Schema`;
+  const className = `${params.modelName}Model`;
+  return `/**
+ * ${params.modelName} Model Definition
+ *
+ * Generated by speckeeper scaffold \u2014 customise as needed.
+ */
+import { z } from 'zod';
+import { Model, RelationSchema } from 'speckeeper';
+import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+
+// =============================================================================
+// Schema Definition
+// =============================================================================
+
+export const ${schemaName} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  description: z.string(),
+  relations: z.array(RelationSchema).optional(),
+});
+
+// =============================================================================
+// Type Export
+// =============================================================================
+
+export type ${params.modelName} = z.input<typeof ${schemaName}>;
+
+// =============================================================================
+// Model Class
+// =============================================================================
+
+class ${className} extends Model<typeof ${schemaName}> {
+  readonly id = '${params.modelId}';
+  readonly name = '${params.modelName}';
+  readonly idPrefix = '${params.idPrefix}';
+  readonly schema = ${schemaName};
+  readonly description = '${params.description}';
+  // TODO: adjust modelLevel
+  protected modelLevel: ModelLevel = '${params.level}';
+
+  protected lintRules: LintRule<${params.modelName}>[] = [
+    {
+      id: '${params.modelId}-has-description',
+      severity: 'warning',
+      message: '${params.modelName} should have a description',
+      check: (spec) => !spec.description || spec.description.trim() === '',
+    },
+  ];
+
+  protected exporters: Exporter<${params.modelName}>[] = [];
+}
+
+export { ${className} };
+`;
+}
+
+// src/scaffold/templates/checkers/ddl-checker.ts
+function generateDdlChecker(_params) {
+  return `import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { ExternalChecker, CheckResult } from 'speckeeper';
+import type { LogicalEntity } from '../_models/logical-entity.ts';
+
+/**
+ * DDL Checker: verifies that logical entity definitions
+ * have corresponding tables/columns in schema.sql.
+ */
+export const ddlChecker: ExternalChecker<LogicalEntity> = {
+  targetType: 'ddl',
+
+  sourcePath: () => resolve('..', 'db', 'schema.sql'),
+
+  check: (spec, _externalData): CheckResult => {
+    const errors: CheckResult['errors'] = [];
+    const warnings: CheckResult['warnings'] = [];
+
+    const schemaPath = resolve('..', 'db', 'schema.sql');
+    if (!existsSync(schemaPath)) {
+      warnings.push({
+        message: \`schema.sql not found: \${schemaPath}\`,
+        specId: spec.id,
+      });
+      return { success: true, errors, warnings };
+    }
+
+    const _schemaSql = readFileSync(schemaPath, 'utf-8');
+
+    // TODO: implement table/column existence check
+    warnings.push({
+      message: \`DDL checker not fully implemented for \${spec.id} \u2014 add table/column verification logic\`,
+      specId: spec.id,
+    });
+
+    return {
+      success: errors.length === 0,
+      errors,
+      warnings,
+    };
+  },
+};
+`;
+}
+
+// src/scaffold/templates/checkers/openapi-checker.ts
+function generateOpenapiChecker(_params) {
+  return `import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { ExternalChecker, CheckResult } from 'speckeeper';
+import type { UseCase } from '../_models/usecase.ts';
+
+/**
+ * OpenAPI Checker: verifies that use cases have corresponding
+ * endpoint definitions in the OpenAPI spec.
+ */
+export const openapiChecker: ExternalChecker<UseCase> = {
+  targetType: 'openapi',
+
+  sourcePath: () => resolve('..', 'api', 'spec'),
+
+  check: (spec, _externalData): CheckResult => {
+    const errors: CheckResult['errors'] = [];
+    const warnings: CheckResult['warnings'] = [];
+
+    const specDir = resolve('..', 'api', 'spec');
+    if (!existsSync(specDir)) {
+      warnings.push({
+        message: \`OpenAPI spec directory not found: \${specDir}\`,
+        specId: spec.id,
+      });
+      return { success: true, errors, warnings };
+    }
+
+    // TODO: implement endpoint existence check
+    warnings.push({
+      message: \`OpenAPI checker not fully implemented for \${spec.id} \u2014 add endpoint verification logic\`,
+      specId: spec.id,
+    });
+
+    return {
+      success: errors.length === 0,
+      errors,
+      warnings,
+    };
+  },
+};
+`;
+}
+
+// src/scaffold/templates/checkers/test-checker.ts
+function generateTestChecker(params) {
+  return `import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { glob } from 'glob';
+import type { ExternalChecker, CheckResult } from 'speckeeper';
+import type { ${params.sourceModelName} } from '../_models/${params.sourceModelFile}.ts';
+
+/**
+ * Test Checker: verifies that ${params.sourceModelName} items have
+ * corresponding test code that exists and references the spec ID.
+ *
+ * Checks:
+ * 1. Test file(s) exist at the expected path
+ * 2. Test file content references the spec ID (in describe/it/test blocks or embedoc markers)
+ */
+export const ${toCamelCase(params.checkerName)}: ExternalChecker<${params.sourceModelName}> = {
+  targetType: '${params.targetType}',
+
+  sourcePath: () => '.',
+
+  check: (spec, _externalData): CheckResult => {
+    const errors: CheckResult['errors'] = [];
+    const warnings: CheckResult['warnings'] = [];
+    const basePath = process.cwd();
+
+    // TODO: configure test file path pattern per spec
+    // For now, search common test directories
+    const testPatterns = [
+      'test/**/*.test.ts',
+      'test/**/*.spec.ts',
+      'tests/**/*.test.ts',
+      'tests/**/*.spec.ts',
+    ];
+
+    let testFiles: string[] = [];
+    for (const pattern of testPatterns) {
+      testFiles = testFiles.concat(glob.sync(pattern, { cwd: basePath }));
+    }
+
+    if (testFiles.length === 0) {
+      warnings.push({
+        message: \`No test files found for \${spec.id}\`,
+        specId: spec.id,
+      });
+      return { success: true, errors, warnings };
+    }
+
+    // Check if spec ID is referenced in any test file
+    let specIdFound = false;
+    for (const testFile of testFiles) {
+      const fullPath = join(basePath, testFile);
+      try {
+        const content = readFileSync(fullPath, 'utf-8');
+        const patterns = [
+          new RegExp(\`describe\\\\s*\\\\(\\\\s*['\\\`"].*\${spec.id}\`, 'm'),
+          new RegExp(\`it\\\\s*\\\\(\\\\s*['\\\`"].*\${spec.id}\`, 'm'),
+          new RegExp(\`test\\\\s*\\\\(\\\\s*['\\\`"].*\${spec.id}\`, 'm'),
+          new RegExp(\`@embedoc.*\${spec.id}\`, 'm'),
+        ];
+        if (patterns.some(p => p.test(content))) {
+          specIdFound = true;
+          break;
+        }
+      } catch {
+        // skip unreadable files
+      }
+    }
+
+    if (!specIdFound) {
+      warnings.push({
+        message: \`Spec ID "\${spec.id}" not found in any test file \u2014 test should reference the spec ID in describe/it/test or embedoc marker\`,
+        specId: spec.id,
+      });
+    }
+
+    return {
+      success: errors.length === 0,
+      errors,
+      warnings,
+    };
+  },
+};
+`;
+}
+function toCamelCase(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+// src/scaffold/templates/checkers/base-checker.ts
+function generateBaseChecker(params) {
+  return `import type { ExternalChecker, CheckResult } from 'speckeeper';
+import type { ${params.sourceModelName} } from '../_models/${params.sourceModelFile}.ts';
+
+/**
+ * ${params.checkerName}: verifies ${params.sourceModelName} against external ${params.targetType} artifacts.
+ *
+ * Generated by speckeeper scaffold \u2014 implement check logic.
+ */
+export const ${toCamelCase2(params.checkerName)}: ExternalChecker<${params.sourceModelName}> = {
+  targetType: '${params.targetType}',
+
+  sourcePath: () => '.',
+
+  check: (spec, _externalData): CheckResult => {
+    const errors: CheckResult['errors'] = [];
+    const warnings: CheckResult['warnings'] = [];
+
+    // TODO: implement check logic for ${params.targetType}
+    warnings.push({
+      message: \`${params.checkerName} not implemented for \${spec.id}\`,
+      specId: spec.id,
+    });
+
+    return {
+      success: errors.length === 0,
+      errors,
+      warnings,
+    };
+  },
+};
+`;
+}
+function toCamelCase2(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+// src/scaffold/templates/index.ts
+var MODEL_TEMPLATE_FUNCTIONS = {
+  requirement: generateRequirementModel,
+  usecase: generateUseCaseModel,
+  term: generateTermModel,
+  entity: generateEntityModel,
+  "logical-entity": generateLogicalEntityModel,
+  "acceptance-test": generateAcceptanceTestModel,
+  "data-test": generateDataTestModel,
+  "validation-constraint": generateValidationConstraintModel,
+  base: generateBaseModel
+};
+var CHECKER_TEMPLATE_FUNCTIONS = {
+  "ddl-checker": generateDdlChecker,
+  "openapi-checker": generateOpenapiChecker,
+  "test-checker": generateTestChecker,
+  "base-checker": generateBaseChecker
+};
+
+// src/scaffold/model-generator.ts
+function generateModelFile(node, _incomingEdges, _outgoingEdges) {
+  const templateInfo = resolveModelTemplate(node.id);
+  const templateFn = MODEL_TEMPLATE_FUNCTIONS[templateInfo.templateName];
+  if (!templateFn) {
+    const baseFn = MODEL_TEMPLATE_FUNCTIONS["base"];
+    return {
+      relativePath: `_models/${templateInfo.fileName}.ts`,
+      content: baseFn({
+        modelId: templateInfo.fileName,
+        modelName: templateInfo.modelName,
+        idPrefix: templateInfo.defaultIdPrefix,
+        level: templateInfo.defaultLevel,
+        description: node.label ?? node.id
+      })
+    };
+  }
+  const content = templateFn({
+    modelId: templateInfo.fileName,
+    modelName: templateInfo.modelName,
+    idPrefix: templateInfo.defaultIdPrefix,
+    level: templateInfo.defaultLevel,
+    description: node.label ?? node.id
+  });
+  return {
+    relativePath: `_models/${templateInfo.fileName}.ts`,
+    content
+  };
+}
+function generateSpecDataFile(node) {
+  const templateInfo = resolveModelTemplate(node.id);
+  const className = `${templateInfo.modelName}Model`;
+  const typeName = templateInfo.modelName;
+  const varName = toCamelCase3(templateInfo.modelName) + "s";
+  const fileName = templateInfo.fileName;
+  const content = `/**
+ * ${templateInfo.modelName} Specifications
+ *
+ * Generated by speckeeper scaffold \u2014 add your specs below.
+ */
+import type { ${typeName} } from './_models/${fileName}';
+import { ${className} } from './_models/${fileName}';
+
+export const ${varName}: ${typeName}[] = [
+  // { id: '${templateInfo.defaultIdPrefix}-001', name: '...', description: '...' },
+];
+
+${className}.instance.register(${varName});
+`;
+  return {
+    relativePath: `${fileName}.ts`,
+    content
+  };
+}
+function toCamelCase3(pascalCase) {
+  return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+function generateAllModelFiles(speckeeperNodes, resolvedEdges) {
+  const files = [];
+  const generated = /* @__PURE__ */ new Set();
+  for (const node of speckeeperNodes) {
+    const templateInfo = resolveModelTemplate(node.id);
+    const key = templateInfo.templateName === "base" ? `base:${node.id}` : templateInfo.templateName;
+    if (generated.has(key)) continue;
+    generated.add(key);
+    resolvedEdges.filter((e) => e.targetId === node.id);
+    resolvedEdges.filter((e) => e.sourceId === node.id);
+    files.push(generateModelFile(node));
+    files.push(generateSpecDataFile(node));
+  }
+  return files;
+}
+
+// src/scaffold/checker-generator.ts
+function findCheckerEdges(resolvedEdges, nodes, speckeeperClassName) {
+  const isSpk = (id) => nodes.get(id)?.classes.includes(speckeeperClassName) ?? false;
+  return resolvedEdges.filter((edge) => {
+    if (!isCheckEdge(edge.vocabulary)) return false;
+    if (!isSpk(edge.sourceId)) return false;
+    if (isSpk(edge.targetId)) return false;
+    return true;
+  });
+}
+function generateCheckerFile(edge, _nodes) {
+  const checkerInfo = resolveCheckerTemplate(edge.targetId);
+  const sourceTemplateInfo = resolveModelTemplate(edge.sourceId);
+  if (checkerInfo) {
+    const templateFn = CHECKER_TEMPLATE_FUNCTIONS[checkerInfo.templateName];
+    if (templateFn) {
+      return {
+        relativePath: `_checkers/${checkerInfo.fileName}.ts`,
+        content: templateFn({
+          checkerName: checkerInfo.fileName,
+          targetType: checkerInfo.targetType,
+          sourceModelName: sourceTemplateInfo.modelName,
+          sourceModelFile: sourceTemplateInfo.fileName,
+          description: `Checks ${sourceTemplateInfo.modelName} against ${edge.targetId}`
+        })
+      };
+    }
+  }
+  const baseFn = CHECKER_TEMPLATE_FUNCTIONS["base-checker"];
+  const targetId = edge.targetId.toLowerCase();
+  const fileName = `${targetId}-checker`;
+  return {
+    relativePath: `_checkers/${fileName}.ts`,
+    content: baseFn({
+      checkerName: fileName,
+      targetType: targetId,
+      sourceModelName: sourceTemplateInfo.modelName,
+      sourceModelFile: sourceTemplateInfo.fileName,
+      description: `Checks ${sourceTemplateInfo.modelName} against ${edge.targetId}`
+    })
+  };
+}
+function generateAllCheckerFiles(resolvedEdges, nodes, speckeeperClassName) {
+  const checkerEdges = findCheckerEdges(resolvedEdges, nodes, speckeeperClassName);
+  const files = [];
+  const generated = /* @__PURE__ */ new Set();
+  for (const edge of checkerEdges) {
+    if (generated.has(edge.targetId)) continue;
+    generated.add(edge.targetId);
+    files.push(generateCheckerFile(edge));
+  }
+  return files;
+}
+
+// src/scaffold/index-generator.ts
+function extractExportedClassNames(content) {
+  const match = content.match(/export\s*\{([^}]+)\}\s*;?\s*$/m);
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function generateModelsIndex(modelFiles) {
+  const entries = [];
+  for (const file of modelFiles) {
+    const fileName = file.relativePath.replace(/^_models\//, "").replace(/\.ts$/, "");
+    const classNames = extractExportedClassNames(file.content);
+    if (classNames.length > 0) {
+      entries.push({ fileName, classNames });
+    }
+  }
+  entries.sort((a, b) => a.fileName.localeCompare(b.fileName));
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * Model index \u2014 generated by speckeeper scaffold");
+  lines.push(" */");
+  lines.push("");
+  for (const entry of entries) {
+    lines.push(`export { ${entry.classNames.join(", ")} } from './${entry.fileName}.js';`);
+  }
+  lines.push("");
+  const modelInstanceNames = entries.flatMap(
+    (e) => e.classNames.filter((n) => n.endsWith("Model"))
+  );
+  if (modelInstanceNames.length > 0) {
+    lines.push("import { Model } from 'speckeeper';");
+    lines.push("import type { ZodType } from 'zod';");
+    lines.push("");
+    for (const entry of entries) {
+      const models = entry.classNames.filter((n) => n.endsWith("Model"));
+      if (models.length > 0) {
+        lines.push(`import { ${models.join(", ")} } from './${entry.fileName}.js';`);
+      }
+    }
+    lines.push("");
+    lines.push("// eslint-disable-next-line @typescript-eslint/no-explicit-any");
+    lines.push("export const allModels: Model<ZodType>[] = [");
+    for (const name of modelInstanceNames) {
+      lines.push(`  ${name}.instance as Model<ZodType>,`);
+    }
+    lines.push("];");
+  }
+  lines.push("");
+  return {
+    relativePath: "_models/index.ts",
+    content: lines.join("\n")
+  };
+}
+
+// src/cli/scaffold.ts
+var SPECKEEPER_CLASS = "speckeeper";
+async function scaffoldCommand(options) {
+  console.log(chalk4.blue("speckeeper scaffold"));
+  console.log("");
+  const sourcePath = resolve(options.source);
+  if (!existsSync(sourcePath)) {
+    console.error(chalk4.red(`  Error: Source file not found: ${sourcePath}`));
+    process.exit(1);
+  }
+  const markdown = readFileSync(sourcePath, "utf-8");
+  const flowchart = parseMarkdownFlowchart(markdown);
+  if (!flowchart) {
+    console.error(chalk4.red("  Error: No mermaid flowchart found in the source file"));
+    process.exit(1);
+  }
+  console.log(chalk4.gray(`  Parsed: ${flowchart.nodes.size} nodes, ${flowchart.edges.length} edges`));
+  const speckeeperNodes = [];
+  for (const node of flowchart.nodes.values()) {
+    if (node.classes.includes(SPECKEEPER_CLASS)) {
+      speckeeperNodes.push(node);
+    }
+  }
+  if (speckeeperNodes.length === 0) {
+    console.error(chalk4.red(`  Error: No nodes with class "${SPECKEEPER_CLASS}" found`));
+    console.log(chalk4.gray("  Add `classDef speckeeper ...` and `class NODE1,NODE2 speckeeper` to your flowchart"));
+    process.exit(1);
+  }
+  console.log(chalk4.gray(`  speckeeper-managed nodes: ${speckeeperNodes.map((n) => n.id).join(", ")}`));
+  const { resolved, diagnostics } = resolveEdges(
+    flowchart.edges,
+    flowchart.nodes,
+    SPECKEEPER_CLASS
+  );
+  printDiagnostics(diagnostics);
+  const outputDir = options.output ? resolve(options.output) : join(process.cwd(), "design");
+  const modelFiles = generateAllModelFiles(speckeeperNodes, resolved);
+  const checkerFiles = generateAllCheckerFiles(resolved, flowchart.nodes, SPECKEEPER_CLASS);
+  const indexFile = generateModelsIndex(modelFiles);
+  const allFiles = [...modelFiles, indexFile, ...checkerFiles];
+  console.log("");
+  console.log(chalk4.cyan(`  Files to generate (${allFiles.length}):`));
+  for (const file of allFiles) {
+    console.log(chalk4.gray(`    ${file.relativePath}`));
+  }
+  if (options.dryRun) {
+    console.log("");
+    console.log(chalk4.yellow("  Dry run \u2014 no files written"));
+    console.log("");
+    for (const file of allFiles) {
+      console.log(chalk4.cyan(`  === ${file.relativePath} ===`));
+      console.log(file.content);
+    }
+    return;
+  }
+  console.log("");
+  let created = 0;
+  let skipped = 0;
+  for (const file of allFiles) {
+    const fullPath = join(outputDir, file.relativePath);
+    const dir = dirname(fullPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    if (existsSync(fullPath) && !options.force) {
+      console.log(chalk4.yellow(`  Skipped: ${file.relativePath} (already exists, use --force to overwrite)`));
+      skipped++;
+      continue;
+    }
+    writeFileSync(fullPath, file.content);
+    console.log(chalk4.green(`  Created: ${file.relativePath}`));
+    created++;
+  }
+  console.log("");
+  console.log(chalk4.cyan(`  Done: ${created} created, ${skipped} skipped`));
+}
+function printDiagnostics(diagnostics) {
+  if (diagnostics.length === 0) return;
+  console.log("");
+  console.log(chalk4.cyan("  Diagnostics:"));
+  for (const diag of diagnostics) {
+    const prefix = diag.severity === "error" ? chalk4.red("  ERROR") : diag.severity === "warning" ? chalk4.yellow("  WARN ") : chalk4.gray("  INFO ");
+    const ctx = diag.context ? chalk4.gray(` [${diag.context}]`) : "";
+    console.log(`${prefix} ${diag.message}${ctx}`);
+  }
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("speckeeper").description("Requirements and design management framework with TypeScript DSL").version("0.1.0");
@@ -1105,6 +2508,7 @@ program.command("check").description("Check external SSOT conformance (including
 program.command("new").description("Create a new element with auto-generated ID").argument("<type>", "Type: requirement, usecase, entity, component, screen, flow, error-case, term").option("-k, --kind <kind>", "Sub-kind (e.g., functional, non-functional for requirements)").option("-n, --name <name>", "Name of the element").option("-o, --output <path>", "Output directory path").option("-t, --template <path>", "Path to template file").action(newCommand);
 program.command("impact").description("Analyze impact of changes to an ID").argument("<id>", "ID to analyze (e.g., REQ-001, ENT-ORDER)").option("-c, --config <path>", "Path to config file").option("-d, --depth <depth>", "Analysis depth (reference tracking level)", "3").option("--direction <direction>", "Analysis direction: upstream, downstream, both", "both").option("-f, --format <format>", "Output format: text, json, mermaid", "text").action(impactCommand);
 program.command("init").description("Initialize a new speckeeper project with starter templates").option("-f, --force", "Overwrite existing files").action(runInit);
+program.command("scaffold").description("Generate _models/ and _checkers/ from a mermaid flowchart definition").requiredOption("-s, --source <path>", "Path to Markdown file containing mermaid flowchart").option("-o, --output <path>", "Output directory (default: design/)").option("-f, --force", "Overwrite existing files").option("--dry-run", "Preview generated files without writing").action(scaffoldCommand);
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map