speckeeper 0.4.2 → 0.6.0

package/dist/cli.js

@@ -108,6 +108,7 @@ var RELATION_TYPES = [
   "implements",
   "refines",
   "verifies",
+  "verifiedBy",
   "satisfies",
   "traces",
   "relatedTo"
@@ -825,7 +826,9 @@ function parseFlowchart(mermaidSource) {
   const edges = [];
   const classDefs = [];
   const classAssignments = [];
+  const subgraphs = [];
   let direction = "TB";
+  const subgraphStack = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line || line.startsWith("%%")) continue;
@@ -839,6 +842,27 @@ function parseFlowchart(mermaidSource) {
       if (gMatch) direction = gMatch[1];
       continue;
     }
+    const subgraphMatch = line.match(/^subgraph\s+(\S+)(?:\s*\[([^\]]*)\])?/);
+    if (subgraphMatch) {
+      const sg = {
+        id: subgraphMatch[1],
+        label: subgraphMatch[2] || void 0,
+        nodeIds: []
+      };
+      subgraphStack.push(sg);
+      continue;
+    }
+    if (line === "end" && subgraphStack.length > 0) {
+      const completed = subgraphStack.pop();
+      subgraphs.push(completed);
+      for (const nodeId of completed.nodeIds) {
+        const node = nodes.get(nodeId);
+        if (node) {
+          node.subgraph = completed.id;
+        }
+      }
+      continue;
+    }
     const classDefMatch = line.match(/^classDef\s+(\S+)\s+(.*)/);
     if (classDefMatch) {
       classDefs.push({ name: classDefMatch[1], styles: classDefMatch[2] });
@@ -868,15 +892,24 @@ function parseFlowchart(mermaidSource) {
           rawLabel: label,
           direction: dir
         });
+        if (subgraphStack.length > 0) {
+          const current = subgraphStack[subgraphStack.length - 1];
+          if (!current.nodeIds.includes(sourceId)) current.nodeIds.push(sourceId);
+          if (!current.nodeIds.includes(targetId)) current.nodeIds.push(targetId);
+        }
       }
       continue;
     }
     const standaloneNode = tryParseStandaloneNode(line);
     if (standaloneNode) {
       ensureNode(nodes, standaloneNode.id, standaloneNode.label);
+      if (subgraphStack.length > 0) {
+        const current = subgraphStack[subgraphStack.length - 1];
+        if (!current.nodeIds.includes(standaloneNode.id)) current.nodeIds.push(standaloneNode.id);
+      }
     }
   }
-  return { direction, nodes, edges, classDefs, classAssignments };
+  return { direction, nodes, edges, classDefs, classAssignments, subgraphs };
 }
 function parseMarkdownFlowchart(markdown) {
   const blocks = extractMermaidBlocks(markdown);
@@ -953,7 +986,22 @@ function tryParseStandaloneNode(line) {
 
 // src/scaffold/edge-vocabulary.ts
 var EDGE_VOCABULARY = [
-  // A. lint targets (speckeeper ↔ speckeeper reference integrity)
+  // check: speckeeper → external SSOT
+  {
+    label: "implements",
+    expectedDirection: "forward",
+    relationType: "implements",
+    category: "check",
+    description: "Spec is implemented as external artifact (OpenAPI, DDL, etc.)"
+  },
+  {
+    label: "verifiedBy",
+    expectedDirection: "forward",
+    relationType: "verifiedBy",
+    category: "check",
+    description: "Spec is verified by external test code"
+  },
+  // lint: speckeeper ↔ speckeeper with level constraint
   {
     label: "refines",
     expectedDirection: "forward",
@@ -961,6 +1009,7 @@ var EDGE_VOCABULARY = [
     category: "lint",
     description: "Decompose higher-level item into lower-level detail"
   },
+  // lint: speckeeper ↔ speckeeper generic reference integrity
   {
     label: "relatedTo",
     expectedDirection: "bidirectional",
@@ -975,50 +1024,41 @@ var EDGE_VOCABULARY = [
     category: "lint",
     description: "Reference / dependency"
   },
-  // B. check targets (speckeeper → external SSOT)
   {
-    label: "implements",
+    label: "dependsOn",
     expectedDirection: "forward",
-    relationType: "implements",
-    category: "check",
-    description: "Realize speckeeper spec as external artifact, interface, or test"
+    relationType: "dependsOn",
+    category: "lint",
+    description: "Dependency relationship"
+  },
+  {
+    label: "satisfies",
+    expectedDirection: "forward",
+    relationType: "satisfies",
+    category: "lint",
+    description: "Satisfies business/requirements"
   },
-  // C. coverage targets
   {
     label: "includes",
     expectedDirection: "forward",
     relationType: "includes",
-    category: "coverage",
+    category: "lint",
     description: "Parent contains child items"
   },
   {
     label: "traces",
     expectedDirection: "forward",
     relationType: "traces",
-    category: "coverage",
+    category: "lint",
     description: "Derive target from source"
   },
+  // external: test code → implementation code (no checker generated)
   {
     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"
+    category: "external",
+    description: "Test code tests implementation code (external \u2192 external, no checker)"
   }
 ];
 var EXTERNAL_LABELS = [
@@ -1078,6 +1118,11 @@ function normalizeLabel(rawLabel, vocabulary = SORTED_VOCABULARY) {
   }
   return null;
 }
+var TEST_CLASSES = /* @__PURE__ */ new Set(["test", "e2e-test", "unit-test", "integration-test"]);
+function isTestLikeByClass(node) {
+  if (!node) return false;
+  return node.classes.some((c) => TEST_CLASSES.has(c) || c.includes("test"));
+}
 function resolveEdges(edges, nodes, speckeeperClassName) {
   const diagnostics = [];
   const resolved = [];
@@ -1149,14 +1194,26 @@ function resolveEdges(edges, nodes, speckeeperClassName) {
         });
       }
     }
-    if (norm.entry.label === "includes" || norm.entry.label === "traces") {
-      if (!isSpk(edge.sourceId) || !isSpk(edge.targetId)) {
+    if (norm.entry.label === "verifiedBy") {
+      if (isSpk(edge.sourceId) && isSpk(edge.targetId)) {
         diagnostics.push({
           severity: "warning",
-          message: `"${norm.entry.label}" should connect two speckeeper-managed nodes`,
+          message: '"verifiedBy" should be speckeeper \u2192 external; it represents verification by external test code',
           context: `${edge.sourceId} \u2192 ${edge.targetId}`
         });
       }
+      const targetNode = nodes.get(edge.targetId);
+      if (targetNode && !isTestLikeByClass(targetNode)) {
+        const targetId = edge.targetId.toUpperCase();
+        const looksLikeTest = ["UT", "IT", "DUT", "E2ET"].includes(targetId) || targetId.includes("TEST") || (targetNode.label ?? "").toLowerCase().includes("test");
+        if (!looksLikeTest) {
+          diagnostics.push({
+            severity: "warning",
+            message: `"verifiedBy" target "${edge.targetId}" does not appear to be a test node; verifiedBy is intended for test targets`,
+            context: `${edge.sourceId} \u2192 ${edge.targetId}`
+          });
+        }
+      }
     }
   }
   return { resolved, diagnostics };
@@ -1166,86 +1223,40 @@ function isCheckEdge(entry) {
 }
 
 // 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];
+var LEVEL_PATTERNS = [
+  { pattern: /^L0$|business|domain/i, level: "L0" },
+  { pattern: /^L1$|requirement/i, level: "L1" },
+  { pattern: /^L2$|design|architecture/i, level: "L2" },
+  { pattern: /^L3$|implementation|external/i, level: "L3" }
+];
+function inferLevelFromSubgraph(subgraphId) {
+  if (!subgraphId) return "L0";
+  for (const { pattern, level } of LEVEL_PATTERNS) {
+    if (pattern.test(subgraphId)) return level;
+  }
+  return "L0";
+}
+var SPECKEEPER_CLASS = "speckeeper";
+function resolveModelTemplate(nodeId, nodeClasses, subgraphId) {
+  const level = inferLevelFromSubgraph(subgraphId);
+  const artifactClass = nodeClasses?.find((c) => c !== SPECKEEPER_CLASS);
+  if (!artifactClass) {
     return {
-      templateName,
-      defaultLevel: meta.level,
+      templateName: "base",
+      defaultLevel: level,
       defaultIdPrefix: nodeId,
-      modelName: meta.primaryTypeName,
-      fileName: meta.fileName
+      modelName: toPascalCase(nodeId),
+      fileName: toKebabCase(nodeId)
     };
   }
   return {
     templateName: "base",
-    defaultLevel: "L1",
+    defaultLevel: level,
     defaultIdPrefix: nodeId,
-    modelName: toPascalCase(nodeId),
-    fileName: toKebabCase(nodeId)
+    modelName: toPascalCase(artifactClass),
+    fileName: toKebabCase(artifactClass)
   };
 }
-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("");
 }
@@ -1253,682 +1264,6 @@ 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`;
@@ -1941,6 +1276,7 @@ function generateBaseModel(params) {
 import { z } from 'zod';
 import { Model, RelationSchema } from 'speckeeper';
 import type { LintRule, Exporter, ModelLevel } from 'speckeeper';
+import { requireField } from 'speckeeper/dsl';
 
 // =============================================================================
 // Schema Definition
@@ -1973,12 +1309,7 @@ class ${className} extends Model<typeof ${schemaName}> {
   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() === '',
-    },
+    requireField<${params.modelName}>('description'),
   ];
 
   protected exporters: Exporter<${params.modelName}>[] = [];
@@ -1988,278 +1319,81 @@ 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);
+function resolveCheckerBindings(_nodeId, outgoingEdges, nodes, speckeeperClassName) {
+  const isSpk = (id) => nodes.get(id)?.classes.includes(speckeeperClassName) ?? false;
+  const bindings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const edge of outgoingEdges) {
+    if (!isCheckEdge(edge.vocabulary)) continue;
+    if (isSpk(edge.targetId)) continue;
+    if (seen.has(edge.targetId)) continue;
+    seen.add(edge.targetId);
+    const targetNode = nodes.get(edge.targetId);
+    const targetClass = targetNode?.classes.find((c) => c !== speckeeperClassName) ?? edge.targetId.toLowerCase();
+    const edgeType = edge.normalizedLabel === "verifiedBy" ? "verifiedBy" : "implements";
+    bindings.push({ edgeType, targetNodeId: edge.targetId, targetClass });
+  }
+  return bindings;
+}
+function generateModelFile(node, _incomingEdges, outgoingEdges, allNodes) {
+  const templateInfo = resolveModelTemplate(node.id, node.classes, node.subgraph);
   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({
+  const params = {
     modelId: templateInfo.fileName,
     modelName: templateInfo.modelName,
     idPrefix: templateInfo.defaultIdPrefix,
     level: templateInfo.defaultLevel,
     description: node.label ?? node.id
-  });
+  };
+  let content;
+  if (!templateFn) {
+    content = MODEL_TEMPLATE_FUNCTIONS["base"](params);
+  } else {
+    content = templateFn(params);
+  }
+  const bindings = allNodes ? resolveCheckerBindings(node.id, outgoingEdges, allNodes, "speckeeper") : [];
+  if (bindings.length > 0) {
+    content += generateCheckerBindingComment(bindings);
+  }
   return {
     relativePath: `_models/${templateInfo.fileName}.ts`,
     content
   };
 }
+var CHECKER_FACTORY_MAP = {
+  openapi: "externalOpenAPIChecker",
+  sqlschema: "externalSqlSchemaChecker",
+  test: "testChecker"
+};
+function generateCheckerBindingComment(bindings) {
+  const lines = [
+    "",
+    "// =============================================================================",
+    "// Checker Bindings (auto-detected from flowchart edges)",
+    "// =============================================================================",
+    "//",
+    "// Import and assign to externalChecker in the Model class:",
+    "// import { " + bindings.map((b) => CHECKER_FACTORY_MAP[b.targetClass] ?? "externalSsotChecker").join(", ") + " } from 'speckeeper/dsl';",
+    "//"
+  ];
+  for (const b of bindings) {
+    const factory = CHECKER_FACTORY_MAP[b.targetClass] ?? `/* custom checker for '${b.targetClass}' */`;
+    lines.push(`// ${b.edgeType} \u2192 ${b.targetNodeId} (class: ${b.targetClass}): ${factory}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
 function generateSpecDataFile(node) {
-  const templateInfo = resolveModelTemplate(node.id);
+  const templateInfo = resolveModelTemplate(node.id, node.classes, node.subgraph);
   const className = `${templateInfo.modelName}Model`;
   const typeName = templateInfo.modelName;
-  const varName = toCamelCase3(templateInfo.modelName) + "s";
+  const varName = toCamelCase(templateInfo.modelName) + "s";
   const fileName = templateInfo.fileName;
   const content = `/**
  * ${templateInfo.modelName} Specifications
@@ -2283,19 +1417,20 @@ export default defineSpecs(
     content
   };
 }
-function toCamelCase3(pascalCase) {
+function toCamelCase(pascalCase) {
   return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
 }
 function generateDesignIndex(speckeeperNodes) {
   const generated = /* @__PURE__ */ new Set();
   const specFiles = [];
   for (const node of speckeeperNodes) {
-    const templateInfo = resolveModelTemplate(node.id);
-    const key = templateInfo.templateName === "base" ? `base:${node.id}` : templateInfo.templateName;
+    const templateInfo = resolveModelTemplate(node.id, node.classes, node.subgraph);
+    const hasArtifactClass = node.classes.some((c) => c !== "speckeeper");
+    const key = hasArtifactClass ? templateInfo.fileName : `base:${node.id}`;
     if (generated.has(key)) continue;
     generated.add(key);
     specFiles.push({
-      varName: toCamelCase3(templateInfo.modelName),
+      varName: toCamelCase(templateInfo.modelName),
       fileName: templateInfo.fileName
     });
   }
@@ -2314,77 +1449,35 @@ export default mergeSpecs(${args});
     content
   };
 }
-function generateAllModelFiles(speckeeperNodes, resolvedEdges) {
+function generateAllModelFiles(speckeeperNodes, resolvedEdges, allNodes) {
   const files = [];
   const generated = /* @__PURE__ */ new Set();
+  const templateNodeGroups = /* @__PURE__ */ new Map();
   for (const node of speckeeperNodes) {
-    const templateInfo = resolveModelTemplate(node.id);
-    const key = templateInfo.templateName === "base" ? `base:${node.id}` : templateInfo.templateName;
+    const templateInfo = resolveModelTemplate(node.id, node.classes, node.subgraph);
+    const hasArtifactClass = node.classes.some((c) => c !== "speckeeper");
+    const key = hasArtifactClass ? templateInfo.fileName : `base:${node.id}`;
+    const group = templateNodeGroups.get(key) ?? [];
+    group.push(node);
+    templateNodeGroups.set(key, group);
+  }
+  for (const node of speckeeperNodes) {
+    const templateInfo = resolveModelTemplate(node.id, node.classes, node.subgraph);
+    const hasArtifactClass = node.classes.some((c) => c !== "speckeeper");
+    const key = hasArtifactClass ? templateInfo.fileName : `base:${node.id}`;
     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));
+    const groupNodes = templateNodeGroups.get(key) ?? [node];
+    const groupNodeIds = new Set(groupNodes.map((n) => n.id));
+    const incoming = resolvedEdges.filter((e) => groupNodeIds.has(e.targetId));
+    const outgoing = resolvedEdges.filter((e) => groupNodeIds.has(e.sourceId));
+    files.push(generateModelFile(node, incoming, outgoing, allNodes));
     files.push(generateSpecDataFile(node));
   }
   files.push(generateDesignIndex(speckeeperNodes));
   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);
@@ -2439,7 +1532,7 @@ function generateModelsIndex(modelFiles) {
 }
 
 // src/cli/scaffold.ts
-var SPECKEEPER_CLASS = "speckeeper";
+var SPECKEEPER_CLASS2 = "speckeeper";
 async function scaffoldCommand(options) {
   console.log(chalk4.blue("speckeeper scaffold"));
   console.log("");
@@ -2457,12 +1550,12 @@ async function scaffoldCommand(options) {
   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)) {
+    if (node.classes.includes(SPECKEEPER_CLASS2)) {
       speckeeperNodes.push(node);
     }
   }
   if (speckeeperNodes.length === 0) {
-    console.error(chalk4.red(`  Error: No nodes with class "${SPECKEEPER_CLASS}" found`));
+    console.error(chalk4.red(`  Error: No nodes with class "${SPECKEEPER_CLASS2}" found`));
     console.log(chalk4.gray("  Add `classDef speckeeper ...` and `class NODE1,NODE2 speckeeper` to your flowchart"));
     process.exit(1);
   }
@@ -2470,14 +1563,13 @@ async function scaffoldCommand(options) {
   const { resolved, diagnostics } = resolveEdges(
     flowchart.edges,
     flowchart.nodes,
-    SPECKEEPER_CLASS
+    SPECKEEPER_CLASS2
   );
   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 modelFiles = generateAllModelFiles(speckeeperNodes, resolved, flowchart.nodes);
   const indexFile = generateModelsIndex(modelFiles);
-  const allFiles = [...modelFiles, indexFile, ...checkerFiles];
+  const allFiles = [...modelFiles, indexFile];
   console.log("");
   console.log(chalk4.cyan(`  Files to generate (${allFiles.length}):`));
   for (const file of allFiles) {
@@ -2544,7 +1636,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.command("scaffold").description("Generate _models/ 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