@sungen/driver-data-factory 3.2.12-beta.1 → 3.2.12-beta.11

package/src/generator.ts

@@ -9,7 +9,9 @@
  * payloads, and resolving placeholder error codes through the field's `errorMap`. Same input →
  * same output (determinism is an asset). Nothing here reads a live page or an LLM.
  */
-import type { Catalog, FieldType, DataPoint } from './types';
+import type { Catalog, FieldType, DataPoint, SelectionContext } from './types';
+import { expandBoundaryHint, satisfiesConstraints, ensureBvaComplete, type Validity } from './boundary';
+import { evaluateWhen, fieldFacts, inProfile } from './applicability';
 
 export interface FieldDef {
   name: string;
@@ -57,6 +59,23 @@ export interface ExpandedPoint {
   open?: boolean;
   /** Value could not be synthesized deterministically (missing constraint) — needs input. */
   todo?: string;
+  /**
+   * The generator's expectation for this value: does it satisfy the field's constraints (`valid`) or
+   * violate them (`invalid`)? Computed by the boundary oracle for synthesized points; `valid` for the
+   * happy-path group and `invalid` for declared-invalid values. `validateGenerated` re-checks it — a
+   * mismatch (a `valid`-expected value that fails the constraints, or vice versa) is a defect.
+   */
+  expectedValidity?: Validity;
+  /**
+   * True when the VALUE was synthesized from a numeric/length boundary (so its whole validity claim is
+   * about range). The validator only second-guesses an `invalid` point when it is synthesized — a
+   * literal charset/format invalid (or a security payload) legitimately satisfies the length oracle.
+   */
+  synthesized?: boolean;
+  /** Provenance: `overwrite` when the project's `.overwrite` replaced/added this point (else shipped). */
+  source?: 'shipped' | 'overwrite';
+  /** Bucket: `adversarial` = a security/injection payload (rendered separately from plain invalid). */
+  category?: 'adversarial';
 }
 
 export interface ExpandedField {
@@ -68,78 +87,36 @@ export interface ExpandedField {
   children?: ExpandedField[];
   /** Recorded inter-field dependency (metadata only — not resolved deterministically). */
   dependsOn?: { field: string; value?: string };
+  /** Cases NOT materialized for the selection context (applicability) — surfaced, never silent. */
+  excluded?: Array<{ id: string; reason: string }>;
 }
 
-/** Deterministic filler: a string of exactly `n` chars from a charset seed. */
-function fillLen(n: number, base = 'a'): string {
-  if (!Number.isFinite(n) || n <= 0) return '';
-  return base.repeat(n).slice(0, n);
-}
-
-/** Build an email of a given total or local length (half-width), with a boundary offset (-1/0/+1). */
-function synthEmail(constraints: Record<string, any>, which: 'maxLocal' | 'maxTotal', offset = 0): string | null {
-  const domain = '@example.com';
-  if (which === 'maxLocal' && Number.isFinite(constraints.maxLocal)) {
-    return fillLen(constraints.maxLocal + offset) + domain;
-  }
-  if (which === 'maxTotal' && Number.isFinite(constraints.maxTotal)) {
-    const localLen = Math.max(1, constraints.maxTotal + offset - domain.length);
-    return fillLen(localLen) + domain;
+/**
+ * Coerce an out-of-range numeric VALID literal into range, so a project's `valid` representative is
+ * actually valid for its constraints (a generic catalog example like `123` under `max: 100` becomes
+ * `100`). Returns null when in range already, or the type isn't numeric (non-numeric mismatches are
+ * left for the validator to flag — the field-map should supply a fitting value).
+ */
+function coerceValidNumeric(type: string, value: string, c: Record<string, any>): string | null {
+  if (!['number-integer', 'number-float', 'currency'].includes(type)) return null;
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  let out = n;
+  if (Number.isFinite(c.min) && out < c.min) out = c.min;
+  if (Number.isFinite(c.max) && out > c.max) out = c.max;
+  if (out === n) return null; // already in range
+  if (type === 'number-float' || (type === 'currency' && c.decimalPlaces > 0)) {
+    const dp = Number.isFinite(c.decimalPlaces) ? c.decimalPlaces : 2;
+    return out.toFixed(dp);
   }
-  return null;
+  return String(Math.round(out));
 }
 
-/** Try to synthesize a boundary/gen value from constraints. Returns null when data is insufficient. */
-function synthesize(dp: DataPoint, type: string, c: Record<string, any>): { value: string | null; todo?: string } {
-  if (dp.value != null) return { value: dp.value };
-  const hint = `${dp.gen || ''} ${dp.note || ''}`.toLowerCase();
-
-  // Email length boundaries. `>` / "over" → over-boundary (invalid, offset +1).
-  if (type === 'email') {
-    const over = hint.includes('>') || hint.includes('over');
-    const offset = over ? 1 : hint.includes('-1') ? -1 : hint.includes('+1') ? 1 : 0;
-    if (hint.includes('maxlocal') || (hint.includes('local') && (hint.includes('max') || over))) {
-      const v = synthEmail(c, 'maxLocal', offset); return v ? { value: v } : { value: null, todo: 'maxLocal' };
-    }
-    if (hint.includes('maxtotal') || hint.includes('total')) {
-      const v = synthEmail(c, 'maxTotal', offset); return v ? { value: v } : { value: null, todo: 'maxTotal' };
-    }
-  }
-
-  // String-length types: min / max length boundaries.
-  const strTypes = ['string', 'password', 'phone', 'postcode', 'katakana'];
-  if (strTypes.includes(type)) {
-    const min = c.minLength ?? c.length;
-    const max = c.maxLength ?? c.length;
-    if (hint.includes('min') && Number.isFinite(min)) {
-      const n = hint.includes('+1') ? min + 1 : min;
-      return { value: fillLen(n, type === 'password' ? 'Aa1' : 'a') };
-    }
-    if (hint.includes('max') && Number.isFinite(max)) {
-      const n = hint.includes('-1') ? max - 1 : max;
-      return { value: fillLen(n, type === 'password' ? 'Aa1' : 'a') };
-    }
-    return { value: null, todo: 'minLength/maxLength' };
-  }
-
-  // Numeric types: min / max value boundaries.
-  const numTypes = ['number-integer', 'number-float', 'currency'];
-  if (numTypes.includes(type)) {
-    const min = c.min, max = c.max;
-    if (hint.includes('min') && Number.isFinite(min)) {
-      if (hint.includes('-1')) return { value: String(min - 1) };
-      if (hint.includes('+1')) return { value: String(min + 1) };
-      return { value: String(min) };
-    }
-    if (hint.includes('max') && Number.isFinite(max)) {
-      if (hint.includes('+1')) return { value: String(max + 1) };
-      if (hint.includes('-1')) return { value: String(max - 1) };
-      return { value: String(max) };
-    }
-    return { value: null, todo: 'min/max' };
-  }
-
-  return { value: null, todo: 'value/gen not resolvable' };
+/** A gen hint that references a numeric/length boundary the generator can expand structurally. */
+function isBoundaryHint(hint: string): boolean {
+  return /\bmin\b|\bmax\b|minimum|maximum|length|byte|exact|decimal|precision|local|total|over|below|under|exceed|\+\s*1|-\s*1|<|>/.test(
+    hint.toLowerCase(),
+  );
 }
 
 function resolveError(dp: DataPoint, errorMap?: Record<string, string>): { expectedError?: string; open?: boolean } {
@@ -163,7 +140,7 @@ function makeUnique(value: string, type: string): string {
 }
 
 /** Expand one field into valid/boundary/invalid data points using the effective catalog. */
-export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
+export function expandField(field: FieldDef, catalog: Catalog, ctx: SelectionContext = {}): ExpandedField {
   // Group / nested field: no own type — expand each sub-field recursively.
   if (field.fields && field.fields.length) {
     return {
@@ -171,7 +148,7 @@ export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
       type: undefined,
       blindSpot: false,
       points: [],
-      children: field.fields.map((sub) => expandField(sub, catalog)),
+      children: field.fields.map((sub) => expandField(sub, catalog, ctx)),
       ...(field.dependsOn ? { dependsOn: field.dependsOn } : {}),
     };
   }
@@ -179,26 +156,88 @@ export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
   if (!ft) return { name: field.name, type: field.type, blindSpot: true, points: [], ...(field.dependsOn ? { dependsOn: field.dependsOn } : {}) };
 
   const c = { ...(ft.constraints || {}), ...(field.constraints || {}) };
+  const type = field.type as string;
   const points: ExpandedPoint[] = [];
+  const excluded: Array<{ id: string; reason: string }> = [];
+  const facts = fieldFacts(field, c);
 
-  const push = (dp: DataPoint, group: ExpandedPoint['group']) => {
-    const s = synthesize(dp, field.type, c);
-    // Uniqueness: only the VALID (happy-path create) value gets a fresh-per-run suffix. Boundary/invalid
-    // stay literal — they test rules, not record creation.
-    const value = group === 'valid' && field.unique && s.value != null
-      ? makeUnique(s.value, field.type)
-      : s.value;
-    points.push({
+  // Gate a catalog case by applicability (`when`) then by the selection profile. A `when` miss is
+  // reported as excluded (not silently dropped); a profile miss is an explicit selection (not reported).
+  const admit = (dp: DataPoint, group: ExpandedPoint['group'], category?: 'adversarial'): boolean => {
+    const ap = evaluateWhen(dp.when, facts, ctx);
+    if (!ap.applicable) { excluded.push({ id: dp.id, reason: ap.reason || 'not applicable' }); return false; }
+    return inProfile(group, category, ctx.profile);
+  };
+
+  // Default validity for a group: the happy path is valid; the invalid group is invalid; a boundary
+  // point's validity is decided per-point by the oracle (in/out of range).
+  const groupValidity = (group: ExpandedPoint['group']): Validity => (group === 'invalid' ? 'invalid' : 'valid');
+
+  const emit = (p: Omit<ExpandedPoint, 'expectedValidity'> & { expectedValidity: Validity }) => points.push(p);
+
+  const pushLiteral = (dp: DataPoint, group: ExpandedPoint['group'], value: string | null, opts: { validity?: Validity; label?: string; todo?: string } = {}) => {
+    // A valid representative must be valid for the project: clamp an out-of-range numeric literal.
+    let coerceNote: string | undefined;
+    if (group === 'valid' && value != null && satisfiesConstraints(type, value, c) === false) {
+      const fixed = coerceValidNumeric(type, value, c);
+      if (fixed != null) { value = fixed; coerceNote = 'adjusted to fit constraints'; }
+    }
+    const isUniqueValid = group === 'valid' && field.unique && value != null;
+    const v = isUniqueValid ? makeUnique(value!, type) : value;
+    // Expected validity reflects INTENT by group, so the validator (validateGenerated) can catch a
+    // mismatch against the oracle instead of the mismatch being silently absorbed here:
+    //   - valid group   → `valid` (a value that actually violates the constraints is a VALUE_NOT_VALID).
+    //   - invalid group → `invalid` (declared: charset/format/blocklist/behavior — the length oracle
+    //     cannot "prove" such a literal valid, so it must NOT flip it to valid).
+    //   - boundary group → the oracle decides (that group is precisely about range).
+    let validity: Validity;
+    if (dp.validity) validity = dp.validity;
+    else if (group === 'boundary') {
+      const oracle = satisfiesConstraints(type, isUniqueValid ? value : v, c);
+      validity = oracle == null ? (opts.validity ?? 'valid') : oracle ? 'valid' : 'invalid';
+    } else validity = opts.validity ?? groupValidity(group);
+    emit({
       id: dp.id,
       group,
-      value,
-      todo: s.todo,
+      value: v,
+      todo: opts.todo,
       reason: dp.reason,
-      note: field.unique && group === 'valid' && s.value != null ? `${dp.note ? dp.note + ' · ' : ''}fresh per run` : dp.note,
+      note: isUniqueValid ? `${dp.note ? dp.note + ' · ' : ''}fresh per run` : coerceNote ? `${dp.note ? dp.note + ' · ' : ''}${coerceNote}` : (opts.label ? `${dp.note ? dp.note + ' · ' : ''}${opts.label}` : dp.note),
+      expectedValidity: validity,
+      ...(dp.source === 'overwrite' ? { source: 'overwrite' as const } : {}),
       ...resolveError(dp, field.errorMap),
     });
   };
 
+  const push = (dp: DataPoint, group: ExpandedPoint['group']) => {
+    if (!admit(dp, group)) return; // not applicable / out of profile
+    // Literal value in the catalog/overwrite → one point (oracle still judges its validity).
+    if (dp.value != null) return pushLiteral(dp, group, dp.value);
+
+    const hint = `${dp.gen || ''} ${dp.note || ''}`.trim();
+    // A boundary/length/numeric hint → expand to one case PER boundary point, each with its validity.
+    if (hint && isBoundaryHint(hint)) {
+      const pts = expandBoundaryHint(hint, type, c);
+      for (const bp of pts) {
+        emit({
+          id: dp.id + bp.suffix,
+          group,
+          value: bp.value,
+          todo: bp.todo,
+          reason: dp.reason,
+          note: bp.label && !bp.todo ? `${dp.note ? dp.note + ' · ' : ''}${bp.label}` : dp.note,
+          expectedValidity: dp.validity ?? bp.validity,
+          synthesized: bp.value != null,
+          ...(dp.source === 'overwrite' ? { source: 'overwrite' as const } : {}),
+          ...resolveError(dp, field.errorMap),
+        });
+      }
+      return;
+    }
+    // A non-boundary gen (charset/full-width/format) — can't synthesize deterministically; keep open.
+    pushLiteral(dp, group, null, { validity: groupValidity(group), todo: dp.gen ? `synthesize: ${dp.gen}` : 'value/gen not resolvable' });
+  };
+
   for (const dp of ft.valid || []) push(dp, 'valid');
   for (const dp of ft.boundary || []) push(dp, 'boundary');
   for (const dp of ft.invalid || []) {
@@ -206,11 +245,12 @@ export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
     push(dp, 'invalid');
   }
 
-  // Append security payloads referenced by uses_security.
+  // Append security payloads referenced by uses_security — the `adversarial` category (own bucket).
   for (const bank of ft.uses_security || []) {
     const b = catalog.security[bank];
     if (!b) continue;
     for (const p of b.payloads || []) {
+      if (!admit(p as DataPoint, 'invalid', 'adversarial')) continue;
       points.push({
         id: p.id,
         group: 'invalid',
@@ -218,16 +258,43 @@ export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
         todo: p.value == null ? `security technique: ${p.technique || bank}` : undefined,
         reason: `${bank}: ${(p.reason as string) || (p.kind as string) || (p.technique as string) || ''}`.trim(),
         note: b.oracle,
+        // Adversarial payloads are treated as invalid input (must be rejected/escaped, never accepted).
+        expectedValidity: 'invalid',
+        category: 'adversarial',
       });
     }
   }
 
-  return { name: field.name, type: field.type, blindSpot: false, points, ...(field.dependsOn ? { dependsOn: field.dependsOn } : {}) };
+  // BVA completeness: for every bounded dimension in the constraints, ensure the full
+  // min-1/min/min+1/max-1/max/max+1 set exists — auto-adding only what the catalog left out (e.g. an
+  // email `minLength` the catalog didn't model). Only in-range points are `boundary`; out-of-range are
+  // `invalid`. Appended after the catalog cases so it never overrides an authored one.
+  const idCode = type.toUpperCase().replace(/[^A-Z0-9]/g, '');
+  for (const ex of ensureBvaComplete(type, c, points.map((p) => p.value))) {
+    points.push({
+      id: `CHK-${idCode}-BVA-${ex.label}`,
+      group: ex.group,
+      value: ex.value,
+      expectedValidity: ex.validity,
+      synthesized: true,
+      note: `BVA (auto): ${ex.label}`,
+      ...(ex.validity === 'invalid' ? { reason: `out of bounds (${ex.label})` } : {}),
+    });
+  }
+
+  return {
+    name: field.name,
+    type: field.type,
+    blindSpot: false,
+    points,
+    ...(field.dependsOn ? { dependsOn: field.dependsOn } : {}),
+    ...(excluded.length ? { excluded } : {}),
+  };
 }
 
 /** Expand a whole field-map. */
-export function expandFieldMap(map: FieldMap, catalog: Catalog): ExpandedField[] {
-  return (map.fields || []).map((f) => expandField(f, catalog));
+export function expandFieldMap(map: FieldMap, catalog: Catalog, ctx: SelectionContext = {}): ExpandedField[] {
+  return (map.fields || []).map((f) => expandField(f, catalog, ctx));
 }
 
 /**
@@ -255,13 +322,18 @@ function renderOne(f: ExpandedField): Record<string, any> {
   }
   const valid = f.points.filter((p) => p.group === 'valid');
   const boundary = f.points.filter((p) => p.group === 'boundary');
-  const invalid = f.points.filter((p) => p.group === 'invalid');
-  return {
+  // Plain invalid excludes the adversarial (security) cases — those get their own bucket.
+  const invalid = f.points.filter((p) => p.group === 'invalid' && p.category !== 'adversarial');
+  const adversarial = f.points.filter((p) => p.category === 'adversarial');
+  const row: Record<string, any> = {
     ...dep,
     valid: valid[0]?.value ?? null,
-    boundary: boundary.map((p) => trim({ id: p.id, value: p.value, note: p.note, todo: p.todo })),
-    invalid: invalid.map((p) => trim({ id: p.id, value: p.value, expected_error: p.expectedError, open: p.open, reason: p.reason, todo: p.todo })),
+    boundary: boundary.map((p) => trim({ id: p.id, value: p.value, expected: p.expectedValidity, via: p.source === 'overwrite' ? '.overwrite' : undefined, note: p.note, todo: p.todo })),
+    invalid: invalid.map((p) => trim({ id: p.id, value: p.value, expected: p.expectedValidity, via: p.source === 'overwrite' ? '.overwrite' : undefined, expected_error: p.expectedError, open: p.open, reason: p.reason, todo: p.todo })),
   };
+  if (adversarial.length) row.adversarial = adversarial.map((p) => trim({ id: p.id, value: p.value, reason: p.reason, note: p.note, todo: p.todo }));
+  if (f.excluded?.length) row._not_applicable = f.excluded.map((e) => `${e.id}: ${e.reason}`);
+  return row;
 }
 
 function trim(o: Record<string, any>): Record<string, any> {

package/src/index.ts

@@ -18,17 +18,32 @@ import { registerDataFactoryCommand } from './cli';
 import { dataFactoryCoverageSensor } from './sensor';
 import { dfPreconditionCodegen } from './precondition';
 
-export { loadShippedCatalog, loadEffectiveCatalog, shippedCommonHash, commonDir } from './catalog-loader';
+export { loadShippedCatalog, loadEffectiveCatalog, shippedCommonHash, commonDir, describeProvenance } from './catalog-loader';
 export { expandField, expandFieldMap, renderTestData } from './generator';
 export type { FieldDef, FieldMap, ExpandedField, ExpandedPoint } from './generator';
 export { lintFieldMap, summarize } from './lint';
 export type { LintIssue } from './lint';
+export { validateGenerated, validatePoints } from './validate';
+export type { ValidationFinding } from './validate';
+export { expandBoundaryHint, satisfiesConstraints, ensureBvaComplete, emailOfTotalLength } from './boundary';
+export type { Validity, BoundaryPoint, BvaExtra } from './boundary';
+export { evaluateWhen, inProfile, fieldFacts } from './applicability';
+export { generate, buildRequest, validateRequest, fingerprint, GENERATOR_VERSION, SCHEMA_VERSION } from './contract';
+export type { DataFactoryRequest, DataFactoryResult } from './contract';
+export { loadStateRecipes, validateStateRecipe, buildStatePlan, renderPreconditionBlock, topoSort, hasDatasource, scaffoldRecipe, renderRecipeYaml, guessProvenance } from './state';
+export type { StateRecipe, StateResource, StatePlan, StateFinding, Provenance, Lifecycle } from './state';
+export { crosscheckUnit, crosscheckShared, crosscheckAll, referencedVars } from './crosscheck';
+export type { CrossFinding } from './crosscheck';
+export { detectUnit, hasInputFields, hasFieldMap, detectPreconditionSignals, hasStateDeclaration } from './detect';
+export type { DetectFinding } from './detect';
+export { coverageUnit } from './coverage';
+export type { CoverageFinding } from './coverage';
 export { registerDataFactoryCommand } from './cli';
 export { generateFixture } from './fixture';
-export type { FixtureResult } from './fixture';
+export type { FixtureResult, FixtureExpected, ExpectedRow } from './fixture';
 export { dataFactoryCoverageSensor } from './sensor';
 export { dfPreconditionCodegen } from './precondition';
-export type { Catalog, FieldType, SecurityBank, Technique, DataPoint, OverwriteWarning } from './types';
+export type { Catalog, FieldType, SecurityBank, Technique, Experience, DataPoint, OverwriteWarning, CatalogProvenance, FieldTypeProvenance, SelectionContext, Profile } from './types';
 
 /** Register the Data Factory capability. */
 export function register(registry: CapabilityRegistry): void {

package/src/lint.ts

@@ -6,7 +6,7 @@
  * placeholders). It also surfaces blind spots (type not in catalog) and — via the catalog loader —
  * stale `.overwrite` warnings. Pure functions; no side effects.
  */
-import type { Catalog } from './types';
+import type { Catalog, SelectionContext } from './types';
 import type { FieldMap, ExpandedField, FieldDef } from './generator';
 import { expandFieldMap } from './generator';
 
@@ -19,8 +19,8 @@ export interface LintIssue {
 
 const BOUNDED = new Set(['email', 'string', 'password', 'phone', 'postcode', 'katakana', 'number-integer', 'number-float', 'currency']);
 
-export function lintFieldMap(map: FieldMap, catalog: Catalog): { issues: LintIssue[]; expanded: ExpandedField[] } {
-  const expanded = expandFieldMap(map, catalog);
+export function lintFieldMap(map: FieldMap, catalog: Catalog, ctx: SelectionContext = {}): { issues: LintIssue[]; expanded: ExpandedField[] } {
+  const expanded = expandFieldMap(map, catalog, ctx);
   const issues: LintIssue[] = [];
 
   // Flatten nested groups to leaf fields (dotted path), pairing each with its FieldDef (for `required`).
@@ -65,6 +65,11 @@ export function lintFieldMap(map: FieldMap, catalog: Catalog): { issues: LintIss
     if (def?.required && valid.length === 0) {
       issues.push({ field: path, severity: 'error', code: 'REQUIRED_NO_VALID', message: 'required field with no valid value' });
     }
+    // Applicability (M2b): cases NOT materialized for this field/context — surfaced, never silent.
+    if (f.excluded?.length) {
+      issues.push({ field: path, severity: 'info', code: 'NOT_APPLICABLE',
+        message: `${f.excluded.length} case(s) not applicable here: ${f.excluded.map((e) => `${e.id} (${e.reason})`).join('; ')}` });
+    }
   }
   return { issues, expanded };
 }

package/src/sensor.ts

@@ -5,7 +5,10 @@
  * coverage lint as `sungen data lint` and surfaces the gaps in the generate output — so weak
  * test-data coverage (missing boundary/invalid, unresolved values, unmapped error codes, blind
  * spots) is visible in the standard harness flow, not only when you remember to run `data lint`.
- * A unit with no field-map produces no findings (Data Factory is opt-in per unit).
+ *
+ * Auto-detection (Layer A): even with NO field-map, it NOTICES what's missing — a unit with input
+ * fields but no standardized data, or a spec that describes a stateful precondition the test never
+ * declares — so Sungen nudges QA instead of staying silent (was: "no field-map → nothing to say").
  *
  * Advisory, not gate: the ContextRouter scopes gate sensors by the annotation tags a feature carries,
  * and test-data generation is a design-time concern with no `.feature` tag — so gating here would
@@ -17,6 +20,8 @@ import { parse as parseYaml } from 'yaml';
 import type { Sensor } from '@sun-asterisk/sungen';
 import { loadEffectiveCatalog } from './catalog-loader';
 import { lintFieldMap, summarize } from './lint';
+import { validateGenerated } from './validate';
+import { detectUnit } from './detect';
 import type { FieldMap } from './generator';
 
 export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
@@ -25,11 +30,21 @@ export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
   kind: 'advisory',
   run: ({ dir, cwd }) => {
     const name = basename(dir);
+    // Layer A auto-detection — runs regardless of whether a field-map exists, so a unit that needs
+    // standardization or a declared precondition is NOTICED, not silently skipped.
+    const detected = detectUnit(cwd, dir, name).map((d) => ({
+      sensorId: 'data-factory-coverage',
+      capability: 'data-factory',
+      scenario: d.scenario,
+      message: d.message,
+      severity: d.severity,
+    }));
+
     const fieldMapPath = join(cwd, 'qa', 'data-factory', `${name}.fields.yaml`);
-    if (!existsSync(fieldMapPath)) return []; // opt-in per unit — no field-map, nothing to say
+    if (!existsSync(fieldMapPath)) return detected; // no field-map: report only what detection noticed
     let map: FieldMap;
-    try { map = parseYaml(readFileSync(fieldMapPath, 'utf8')) as FieldMap; } catch { return []; }
-    if (!map || !Array.isArray(map.fields)) return [];
+    try { map = parseYaml(readFileSync(fieldMapPath, 'utf8')) as FieldMap; } catch { return detected; }
+    if (!map || !Array.isArray(map.fields)) return detected;
 
     const { catalog, warnings } = loadEffectiveCatalog(cwd);
     const { issues } = lintFieldMap(map, catalog);
@@ -49,6 +64,17 @@ export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
         severity: 'warn',
       });
     }
+    // Semantic validity (M1): a value labeled valid that violates the constraints (or a synthesized
+    // boundary that lands in-range) — the "structurally right but semantically wrong" class.
+    for (const v of validateGenerated(map, catalog)) {
+      findings.push({
+        sensorId: 'data-factory-coverage',
+        capability: 'data-factory',
+        scenario: v.field,
+        message: `DATA-FACTORY-${v.code}: ${v.message}`,
+        severity: v.severity,
+      });
+    }
     if (findings.length) {
       const s = summarize(issues);
       findings.unshift({
@@ -59,6 +85,8 @@ export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
         severity: s.errors ? 'warn' : 'info',
       });
     }
+    // Detection findings (e.g. an undeclared stateful precondition) are still relevant with a field-map.
+    findings.push(...detected);
     return findings;
   },
 };