@sun-asterisk/sungen 3.2.11 → 3.2.12-beta.2

package/src/exporters/csv-exporter.ts

@@ -25,7 +25,7 @@ import {
 import { ApiCatalogEntry, EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from './types';
 import { collectSecretValues, formatApiExpected, formatApiRequest, hasApiCalls, redactSecrets } from './api-testcase-formatter';
 import { SelectorKeyMap, substituteSelectorKeysInStep } from './selector-key-resolver';
-import { resolveResultVariants } from './result-variants';
+import { formatVariantRow, resolveResultVariants } from './result-variants';
 
 export interface BuildCsvInput {
   screen: string;
@@ -70,7 +70,7 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     // Data-driven (@cases): expand to one CSV row per executed dataset input (Playwright titles
     // "<scenario> — <label>"); plain scenarios resolve their single result. Shared with the
     // dashboard/JSON exporter via resolveResultVariants so the two can't drift on @cases handling.
-    const variants = resolveResultVariants(m, input.results);
+    const variants = resolveResultVariants(m, input.results, input.testData);
 
    for (const variant of variants) {
     const displayName = `${m.feature.name}${variant.nameSuffix}`;
@@ -132,7 +132,11 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     // Multi-line bullet format keeps delivery CSV/XLSX in sync with the
     // dashboard's Test data section. Multi-line CSV cells are valid (quoted
     // automatically) and render natively as multi-line in XLSX.
-    const testData = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');
+    let testData = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');
+    // @cases: each report line shows ITS OWN dataset row (executed auto rows and manual
+    // split rows both carry variant.row) — one line per case, one dataset per line.
+    const variantRow = formatVariantRow(variant, '\n');
+    if (variantRow) testData = testData ? `${testData}\n${variantRow}` : variantRow;
 
     // Status for this (possibly per-input) row — resolved into `variant` above.
     const result: PlaywrightResult | undefined = variant.result;

package/src/exporters/feature-parser.ts

@@ -9,7 +9,7 @@ import { FeatureMetadata, OrderedStep, ScenarioMetadata } from './types';
 /**
  * Variables referenced in a scenario: find all {{var_name}} in step text.
  */
-function extractReferencedVars(scenario: ParsedScenario): string[] {
+function extractReferencedVars(scenario: ParsedScenario, includeComments = false): string[] {
   const vars = new Set<string>();
   for (const step of scenario.steps) {
     const matches = step.text.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_.-]*)\}\}/g);
@@ -28,6 +28,19 @@ function extractReferencedVars(scenario: ParsedScenario): string[] {
       }
     }
   }
+  // Manual scenarios carry their real tester procedure in `# Tester verifies:` comment
+  // blocks — the {{var}} refs there are the data the tester needs, so include them
+  // (issue: manual test cases exported with an empty Test Data cell). Automated
+  // scenarios keep step-only scanning: their comments are notes (SPEC-GAP etc.) and
+  // would only add noise vars to the delivery report.
+  if (includeComments) {
+    for (const line of scenario.comments ?? []) {
+      const matches = line.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_.-]*)\}\}/g);
+      for (const match of matches) {
+        vars.add(match[1]);
+      }
+    }
+  }
   return Array.from(vars);
 }
 
@@ -85,7 +98,7 @@ export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
       tags: [...parsed.tags, ...sc.tags],
       stepsName: sc.stepsName,
       extendsName: sc.extendsName,
-      referencedVars: extractReferencedVars(sc),
+      referencedVars: extractReferencedVars(sc, extractTestcaseType([...parsed.tags, ...sc.tags]) === 'Manual'),
       rawGivenSteps: given,
       rawWhenSteps:  when,
       rawThenSteps:  then,

package/src/exporters/json-exporter.ts

@@ -23,7 +23,7 @@ import {
 } from './playwright-report-parser';
 import { ApiCatalogEntry, EnvironmentInfo, PlaywrightResult } from './types';
 import { SelectorKeyMap, substituteSelectorKeysInStep } from './selector-key-resolver';
-import { resolveResultVariants } from './result-variants';
+import { formatVariantRow, resolveResultVariants } from './result-variants';
 import {
   ScenarioSnapshot,
   ScreenSnapshot,
@@ -123,13 +123,17 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
     }
     // Dashboard modal uses whitespace-pre-wrap — pass '\n' to render one
     // key/value per line instead of the CSV-friendly "; " join.
-    const testDataStr = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');
+    const baseTestDataStr = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');
 
-    // @cases scenarios expand to one snapshot entry per executed dataset row (shared with the CSV
-    // exporter via resolveResultVariants), so their per-row pass/fail is counted — not collapsed
-    // into one Pending/N/A entry as before.
-    const variants = resolveResultVariants(m, input.results ?? null);
+    // @cases scenarios expand to one snapshot entry per executed dataset row — and manual
+    // @cases split per DATASET row (shared with the CSV exporter via resolveResultVariants),
+    // so their per-row pass/fail is counted — not collapsed into one Pending/N/A entry.
+    const variants = resolveResultVariants(m, input.results ?? null, input.testData);
     for (const variant of variants) {
+      // Per-line Test Data: shared vars + THIS variant's dataset row (parity with csv-exporter).
+      let testDataStr = baseTestDataStr;
+      const variantRow = formatVariantRow(variant, '\n');
+      if (variantRow) testDataStr = testDataStr ? `${testDataStr}\n${variantRow}` : variantRow;
       const displayName = `${m.feature.name}${variant.nameSuffix}`;
       const { vpId, category1 } = splitVpAndName(displayName);
       const tcId = generateTcId(input.screen, vpId, fallbackIndex);

package/src/exporters/result-variants.ts

@@ -5,12 +5,42 @@
  */
 import { MergedScenario } from './scenario-merger';
 import { PlaywrightResult } from './types';
+import { extractTestcaseType } from './feature-parser';
 
 export interface ResultVariant {
-  /** Appended to the scenario display name: `''` for a plain scenario, ` — <label>` per executed
+  /** Appended to the scenario display name: `''` for a plain scenario, ` — <label>` per
    *  @cases dataset row (so each row gets a distinct category1). */
   nameSuffix: string;
   result?: PlaywrightResult;
+  /** The @cases dataset row backing this variant — lets the exporters render the row's own
+   *  columns into the Test Data cell (`__`-prefixed bookkeeping keys excluded). Present on
+   *  executed auto rows (matched by label) and on manual split rows. */
+  row?: Record<string, unknown>;
+}
+
+/**
+ * Read the `@cases:<name>` dataset rows for a scenario from the (flattened) test-data map.
+ * `loadTestData()` flattens arrays to JSON strings — accept that shape and raw arrays.
+ * Scalar rows normalize to `{ value }`, mirroring the runtime TestDataLoader.cases().
+ */
+export function getCasesDatasetRows(
+  m: MergedScenario,
+  testData: Record<string, string> | null | undefined,
+): Array<Record<string, unknown>> | null {
+  const tag = m.feature.tags.find((t) => t.startsWith('@cases:'));
+  if (!tag || !testData) return null;
+  let list: unknown = testData[tag.slice('@cases:'.length)];
+  if (typeof list === 'string') {
+    try { list = JSON.parse(list); } catch { return null; }
+  }
+  if (!Array.isArray(list) || list.length === 0) return null;
+  return list.map((row) =>
+    row && typeof row === 'object' && !Array.isArray(row) ? (row as Record<string, unknown>) : { value: row });
+}
+
+/** Display label of a dataset row — mirrors the runtime TestDataLoader.cases() rule. */
+function rowLabel(row: Record<string, unknown>, i: number): string {
+  return String(row.case ?? row.name ?? row.label ?? `row ${i + 1}`);
 }
 
 /**
@@ -18,9 +48,12 @@ export interface ResultVariant {
  *
  * A `@cases:<dataset>` scenario compiles to one `test()` per dataset row, whose Playwright title is
  * `<scenario> — <label>` — expand into one variant per EXECUTED row by matching that prefix (so an
- * already-run row carries its real pass/fail). A plain scenario resolves its single result by the
- * spec test title. With no results — or a @cases scenario with no matching result yet — a lone
- * variant with no result is returned, so the caller marks it Pending / N/A.
+ * already-run row carries its real pass/fail), attaching the backing dataset row by label.
+ *
+ * A MANUAL `@cases` scenario never executes, so that expansion can never fire — split it from the
+ * DATASET instead: one variant per row (` — <label>`, no result → Pending), each carrying its row
+ * so the manual tester gets one report line + its own data per case to walk and record. An auto
+ * @cases scenario that has not run yet stays a single line (its expansion belongs to execution).
  *
  * NOTE: this deliberately does NOT gate on `m.spec`. For @cases the compiled test title carries a
  * `— ${__row.__label}` suffix, so `findMatchingSpecTest` (base-name match) often leaves `m.spec`
@@ -30,13 +63,26 @@ export interface ResultVariant {
 export function resolveResultVariants(
   m: MergedScenario,
   results: Map<string, PlaywrightResult> | null,
+  testData?: Record<string, string> | null,
 ): ResultVariant[] {
   const isCases = m.feature.tags.some((t) => t.startsWith('@cases:'));
-  if (isCases && results) {
-    const marker = `${m.feature.name} — `;
-    const rows = [...results.entries()].filter(([t]) => t.includes(marker));
-    if (rows.length) {
-      return rows.map(([t, r]) => ({ nameSuffix: ` — ${t.slice(t.indexOf(marker) + marker.length)}`, result: r }));
+  if (isCases) {
+    const datasetRows = getCasesDatasetRows(m, testData);
+    const byLabel = new Map<string, Record<string, unknown>>();
+    (datasetRows ?? []).forEach((row, i) => byLabel.set(rowLabel(row, i), row));
+
+    if (results) {
+      const marker = `${m.feature.name} — `;
+      const ran = [...results.entries()].filter(([t]) => t.includes(marker));
+      if (ran.length) {
+        return ran.map(([t, r]) => {
+          const label = t.slice(t.indexOf(marker) + marker.length);
+          return { nameSuffix: ` — ${label}`, result: r, row: byLabel.get(label) };
+        });
+      }
+    }
+    if (datasetRows && extractTestcaseType(m.feature.tags) === 'Manual') {
+      return datasetRows.map((row, i) => ({ nameSuffix: ` — ${rowLabel(row, i)}`, row }));
     }
     return [{ nameSuffix: '' }];
   }
@@ -45,3 +91,16 @@ export function resolveResultVariants(
   }
   return [{ nameSuffix: '' }];
 }
+
+/**
+ * Render a variant's dataset row for the Test Data cell: one `col: value` line per column,
+ * `__`-prefixed bookkeeping keys excluded. Returns '' when the variant carries no row.
+ */
+export function formatVariantRow(variant: ResultVariant, separator: string = '\n'): string {
+  if (!variant.row) return '';
+  const useBullet = separator.includes('\n');
+  return Object.entries(variant.row)
+    .filter(([k]) => !k.startsWith('__'))
+    .map(([k, v]) => `${useBullet ? '• ' : ''}${k}: ${v}`)
+    .join(separator);
+}

package/src/exporters/test-data-resolver.ts

@@ -133,6 +133,7 @@ function truncate(s: string, max: number): string {
   return s.substring(0, max - 1) + '…';
 }
 
+
 /**
  * Resolve `{{var}}` test-data placeholders in a step / expected-result line to their concrete values,
  * so the delivery report shows what QA actually verifies (e.g. `text contains {{app_version}}` →

package/src/harness/capability.ts

@@ -24,6 +24,7 @@ export interface DriverMeta {
   package: string;
   runtime?: string;
   adapter?: string;        // registry adapter name (defaults to id)
+  bundled?: boolean;       // shipped as a core dependency — present without `capability add`
   capabilities: string[];
   unblocks?: string[];
 }

package/src/harness/catalog/drivers.yaml

@@ -51,7 +51,8 @@ drivers:
   data-factory:
     kind: capability
     package: "@sungen/driver-data-factory"
-    status: planned
+    status: shipped
+    bundled: true          # runtime-free knowledge+codegen — shipped by default (no `capability add` needed)
     capabilities: ["@dataFactory"]
     unblocks: [M1]
   mock:

package/src/orchestrator/templates/ai-src/commands/create-data-test.md

@@ -0,0 +1,99 @@
+---
+name: create-data-test
+description: "Generate standardized test-data for a screen/flow from the Data Factory catalog — valid/boundary/invalid values with CHK-* traceability (no free-form guessing)"
+argument-hint: [screen-or-flow-name]
+order: 25
+claude-tools: "Read, Grep, Bash, Glob, Write, Edit, AskUserQuestion, Skill"
+copilot-tools: "[vscode, execute, read, agent, edit, search, todo]"
+codex-trigger: "Run when the user asks to CREATE, generate, or standardize TEST DATA / test values for a screen or flow (valid/boundary/invalid, boundary values, negative data). Uses the Data Factory driver. Not for generating the .feature scenarios themselves (that is create-test)."
+---
+
+**Input**: A screen or flow name (e.g., `/sungen:create-data-test login`), OR **no name** to do every unit (with a confirmation — see ALL mode). Load the `sungen-data-factory` skill for the full method.
+
+> **When to use.** `/sungen:create-test` already standardizes field test-data via Data Factory **inline** (its step 5.3), so you normally do **not** need this command as a follow-up. Use it **on demand** to *re-standardize*: after you edit a field-map or the `.overwrite`, for a unit authored before Data Factory existed, to refresh error-code mappings, or to (re)generate across many units at once (ALL mode). It MERGES into existing test-data (never clobbers).
+
+## Role
+
+You are a **Senior QA Engineer** producing **test data to a standard**, not by guessing. You do NOT invent values field-by-field. You follow the 4-source method (spec rules → field-type catalog → design technique → DB mapping), driven by the **Data Factory** capability driver. Values come from the catalog (`common/` + the project's `.overwrite`), each tagged with a `CHK-*` id that traces back to the spec. Where the catalog cannot cover a project-specific field, you **ask the QA** — you never fabricate domain data.
+
+## Preconditions
+
+1. **Availability** — Data Factory is **bundled with core** (no `capability add` needed); its CLI (`sungen data …`) is available out of the box. Just continue.
+2. Determine mode from `$ARGUMENTS`:
+   - A **name** given → single-unit mode (that screen/flow only).
+   - **No name** → **ALL mode** (see below — always confirm first).
+
+## ALL mode (no name) — confirm before doing everything
+
+If no name was given, the user wants **all** screens/flows — but this is wide, and a missing name is often a typo (they meant `create-data-test home`). So:
+
+1. List every unit under `qa/screens/*` and `qa/flows/*`, and classify each as **new** (no `test-data/<name>.yaml` yet) vs **would-overwrite**.
+2. Show the list and use `AskUserQuestion` to confirm: *"Generate test-data for ALL N units? (X new · Y would overwrite)"* — default to **No**.
+3. Only proceed when the user confirms. Then run the per-unit flow below for each (the CLI `sungen data gen --all` also enforces this confirm; `--yes` after the user agrees).
+
+## Per-unit flow (single unit, or each unit in ALL mode)
+
+Auto-detect: `qa/flows/<name>/` → flow; else `qa/screens/<name>/` → screen. (API units carry their contract in `apis.yaml` — data there is `@cases` in create-test, not this command.)
+
+### 1. Read the sources (Nguồn 1 + 4)
+
+Read `qa/<screens|flows>/<name>/requirements/spec.md` and `test-viewpoint.md`. For **each input field / parameter**, extract:
+- data **type** (map to a catalog field-type: email · password · phone · string · number-integer · number-float · currency · postcode · katakana …),
+- `required`, format, **min/max** length or value,
+- the real **error/message code** the spec shows when a rule is violated,
+- any **DB mapping** (unique, cross-entity dependency) noted in the spec.
+
+Viewpoint tells you which fields are high-priority → give them the fullest data.
+
+**No input fields → nothing to generate.** If the unit is a pure navigation / listing / capture-compare flow (e.g. a home-shopping browse flow) with **no user-input fields or parameters**, Data Factory has nothing to standardize. Report *"`<name>`: no input fields → nothing to generate"* and stop for this unit — do **not** write an empty `qa/data-factory/<name>.fields.yaml`. (Its scenarios are covered by create-test's data, not by field-level test data.)
+
+### 2. Write the field-map — `qa/data-factory/<name>.fields.yaml`
+
+This is the input the deterministic generator expands. One entry per field:
+
+```yaml
+screen: <name>            # or: flow: <name>
+fields:
+  - name: email
+    type: email
+    required: true
+    unique: true                                   # fresh-per-run (register email won't collide)
+    constraints: { maxLocal: 64, maxTotal: 254 }   # project's real limits
+    errorMap: { M13: E1042, M02: E1001 }            # catalog placeholder → project's real code
+  - name: password
+    type: password
+    constraints: { minLength: 8, maxLength: 32 }
+```
+
+**`unique: true`** — set it for a field that must be **different every run** (register email/username that can't clash with a record a previous run created). The valid value then gets a runtime `{{$timestamp}}` (email → `user+{{$timestamp}}@…`), so each run is fresh — no cross-run cache, no order-dependent flakiness. Boundary/invalid values stay literal (they test rules, not record creation).
+
+Map every placeholder error code you can (`errorMap`) to the spec's real code. Leave a code unmapped only if the spec truly has none — the lint will flag it as an open point to confirm with BA/Dev.
+
+**Complex forms — nested & dependent fields.** For a grouped/object field, give it **`fields:`** (sub-fields, expanded recursively; no `type` on the group). For a field whose rule depends on another, add **`dependsOn: { field: <other>, value: <v> }`** — it's recorded as a note so the scenario/`@cases` honor it (the generator doesn't resolve the runtime condition):
+```yaml
+fields:
+  - name: address                       # group → nested object
+    fields:
+      - { name: city, type: string, constraints: { maxLength: 50 } }
+      - { name: postcode, type: postcode, dependsOn: { field: country, value: JP } }
+```
+
+### 3. Blind spots — ask, do not invent
+
+If a field's type is **not** in the catalog (a business enum, a cross-entity constraint, a project data model), **stop and ask the QA** with `AskUserQuestion` for: (1) the valid set, (2) invalid / non-existent values, (3) the error code when wrong, (4) dependencies on other fields. Record the answer in `qa/data-factory/project/<entity>.yaml` for reuse. Never fabricate domain values.
+
+### 4. Lint the coverage
+
+Run (local-first): `[ -x ./bin/sungen.js ] && ./bin/sungen.js data lint --screen <name> || npx sungen data lint --screen <name>`. Fix what it reports: add missing boundary values, resolve `UNRESOLVED` items (supply the constraint), map `OPEN_ERRORREF` codes. The bar is the phuong-phap §6 checklist — every required field has valid + boundary + invalid, one invalid per rule.
+
+### 5. Generate the test-data
+
+Run (local-first): `[ -x ./bin/sungen.js ] && ./bin/sungen.js data gen --screen <name> || npx sungen data gen --screen <name>`. If `test-data/<name>.yaml` already exists it **merges** the standardized field data in — it **replaces only the field keys it owns and preserves every other key** (create-test's data, flow-namespaced keys, `@cases` datasets, overrides). It asks before merging (in ALL mode after they confirmed, add `--yes`; `--force` skips the prompt). The output is standardized `valid/boundary/invalid` values with `CHK-*` traceability.
+
+### 6. Weave into scenarios (if create-test already ran)
+
+If the `.feature` exists, turn the generated invalid/boundary sets into data-driven `Scenario Outline` + `Examples` (`@cases`) referencing the values — following `sungen-gherkin-syntax`. Otherwise leave the standardized `test-data/<name>.yaml` for `/sungen:run-test` to consume.
+
+## After running
+
+Use `AskUserQuestion` to offer the next step: review the generated data, run `/sungen:create-test <name>` (if scenarios don't exist yet), or `/sungen:run-test <name>`.

package/src/orchestrator/templates/ai-src/commands/create-test.md

@@ -167,6 +167,8 @@ If the unit is **api-first** (`qa/api/<name>/` or `qa/api/flows/<name>/`), the d
 
    **5d. Sequential fallback.** Use the single-context incremental path (Step 2: tier-by-tier `Write`/`Edit` batches) when: only **one** shard applies, **Copilot / no sub-agents**, or a constrained setup. Same output, just no speedup. **For flows**: `[Screen:Element]` namespace refs, test-data namespaced by phase, `@flow` tag.
 
+5.3. **Standardize field test-data — Data Factory (when the unit has input fields).** Don't hand-invent per-field values — make them **standard**. For each input field, author the field-map `qa/data-factory/<name>.fields.yaml` (field → catalog `type` + the spec's real `constraints` + `errorMap` placeholder→real code), then run (Bash, local-first) `[ -x ./bin/sungen.js ] && ./bin/sungen.js data lint --screen <name> || npx sungen data lint --screen <name>` and `… data gen --screen <name>`, per the **`sungen-data-factory`** skill. `data gen` **MERGES** into `test-data.yaml` (replaces only its field keys, preserves your scenario/namespaced data), so it is safe to run here. Weave the standardized **boundary/invalid** sets into `@cases` (`Scenario Outline` + `Examples`) with `CHK-*` trace; keep the map's `errorMap`/`constraints` aligned to the spec. **This is the same standard as `/sungen:create-data-test`, applied inline — so you do NOT run that command separately afterwards.** A unit with **no input fields** (navigation / list / capture-compare) → **skip this step** (nothing to standardize).
+
 5.4. **Depth self-check (deterministic — run BEFORE the audit).** Run `sungen depth-lint --screen <name>` (Bash). It reuses the audit's businessDepth classifier and splits every shallow business-critical scenario into two actionable buckets — act on them now so the audit/repair loop doesn't burn rounds on depth:
    - **DEEPEN IN PLACE** — add a real value assertion to each (`User see all [X] contain {{v}}`, `User remember [X] as {{v}}` + `… with {{v}}`). The printed `template` is a **hint** keyed off the theme — apply judgment to the scenario's actual claim; do NOT paste a value assertion that doesn't fit (e.g. a carousel-visibility scenario should assert the product SET, not a price). If a flagged scenario is genuinely visibility/behavior (not data-correctness), that's an over-count — leave it and note it, never fake an assertion.
    - **CROSS-SCREEN** — route to a flow (`/sungen:add-flow`) or tag `@manual:Mx` + reason; do NOT fake an on-screen data assertion. This removes it from the screen's depth denominator honestly.
@@ -194,6 +196,7 @@ If the unit is **api-first** (`qa/api/<name>/` or `qa/api/flows/<name>/`), the d
 4. Follow the `sungen-tc-generation` skill for section identification, viewpoint generation, and output format. **For flows**, use the "Flow Test Generation" section in the skill. When requirements exist, use the "Requirements-Driven Generation" strategy. **For Tier 1**, apply the **Lightweight Guard** — verify required fields, validation rules, business rules, security checks, and key state transitions all have TCs after generation. **For Tier 2+**, **MUST** apply the full **Mapping Contract** — walk every `spec.md` section top-to-bottom and produce the indicated TCs per Table 1; handle `test-viewpoint.md` per Table 2. Do not silently skip sections. Present sections as a numbered list and let user pick.
 5. Generate or update `.feature` + `test-data.yaml` following `sungen-gherkin-syntax` and `sungen-tc-generation` skills. Generate **group-by-group** (one viewpoint group at a time, tier-by-tier `Write`/`Edit` batches) to stay under the output-token cap. **For flows**: use `[Screen:Element]` namespace format, namespace test-data by phase, add `@flow` tag. **If a scenario needs `@query` DB verification**, check the datasource `engine` first — unsupported engine → follow `sungen-gherkin-syntax` § "Unsupported DB engine — fallback" instead of authoring `@query` steps.
    > **No parallel fan-out here.** Copilot has no sub-agents, so generation is sequential (the Claude Code variant fans out one `sungen-generator` per viewpoint group and merges). Same output, no speedup.
+5.3. **Standardize field test-data — Data Factory (when the unit has input fields).** For each input field, author the field-map `qa/data-factory/<name>.fields.yaml` (field → catalog `type` + real `constraints` + `errorMap`), then run `sungen data lint --screen ${input:name}` and `sungen data gen --screen ${input:name}` per the **`sungen-data-factory`** skill. `data gen` **MERGES** into `test-data.yaml` (replaces only its field keys, preserves the rest), so it is safe here. Weave the standardized boundary/invalid sets into `@cases` with `CHK-*` trace. **Same standard as `/sungen:create-data-test`, applied inline — do NOT run that command separately afterwards.** No input fields (navigation/list) → skip.
 5.4. **Depth self-check (deterministic — BEFORE the audit).** Run `sungen depth-lint --screen ${input:name}`. It splits every shallow business-critical scenario into **DEEPEN IN PLACE** (add a real value assertion — the printed `template` is a theme-keyed hint, apply judgment to the actual claim; never fake one onto a visibility/behavior scenario) and **CROSS-SCREEN** (route to a flow / tag `@manual:Mx` + reason — removes it from the depth denominator honestly). Act on both, re-run until `deepen` is empty (or only honest over-counts remain), THEN gate. Lifts first-pass `businessDepth` mechanically instead of via 2–3 repair rounds.
 5.5. **Quality gate & repair (harness — always run).** Per `sungen-harness-audit`: run `sungen audit --screen ${input:name}` (structural), THEN do an **independent semantic review inline** using the `sungen-reviewer` criteria (does each scenario's steps PROVE its title/viewpoint? observable Thens? business-critical assertion depth?). Merge both sets of issues; if gate FAILs / findings exist, repair (budget 3) and re-audit — GATE missing theme → generate it (cross-screen → **automate it in the flow** via `/sungen:add-flow`, NOT a full `@manual` screen duplicate — `sungen audit` flags an automatable `@manual` as `MANUAL-AUTOMATABLE`; reserve `@manual:Mx` for true judgment/missing-capability); DEPTH → add data assertions; BALANCE → add business-core first; TRACE → align VP ids. Never fake a pass.
 5.6. **Record.** `sungen manifest --screen ${input:name}`. Ledger **each phase** (not just repair) — pick one `runId` at the start and pass it so `trace`/`ledger report` show THIS run, not a mix: `sungen ledger record --screen ${input:name} --run <runId> --step <discovery|viewpoint|gherkin|audit|repair:N> --ms <elapsed>`. On re-run, start with `sungen manifest --screen ${input:name} --diff` and only regenerate changed sections.

package/src/orchestrator/templates/ai-src/commands/run-test.md

@@ -127,6 +127,7 @@ If the unit is **api-first**, skip every selector/capture phase (an API test has
 ## Pre-run (phased — per `sungen-selector-fix` skill)
 
 1. Verify `<base>/<name>/` has `.feature` + `test-data.yaml`. **If the feature has `@query` steps**, check the resolved datasource `engine` in `qa/datasources.yaml` — unsupported engine → follow the `sungen-gherkin-syntax` skill § "Unsupported DB engine — fallback" before compiling (do not attempt a direct connect).
+1.5. **Data Factory pre-check (before running)** — Data Factory is bundled with core, so whenever a field-map exists (`qa/data-factory/<name>.fields.yaml`), confirm the test-data is standardized and covers each field before you run: `[ -x ./bin/sungen.js ] && ./bin/sungen.js data lint --screen <name> || npx sungen data lint --screen <name>`. If it reports coverage gaps (missing boundary/invalid, unresolved values, unmapped error codes) or the field-map is newer than `test-data/<name>.yaml`, refresh via `/sungen:create-data-test <name>` (or `sungen data gen --screen <name>`) — then compile. Blind spots (a `type` not in the catalog) are for the QA to answer, not to invent. No field-map / driver disabled → skip this step.
 2. **Phase 0 — Selector Pre-gen**: if `selectors.yaml` is missing/empty or doesn't cover the feature file's `[Reference]`s, apply the following decision tree before running Phase 0 from `sungen-selector-fix`:
 
    ```

package/src/orchestrator/templates/ai-src/config/claude.md

@@ -18,14 +18,16 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `sungen-delivery` | Export Gherkin + Playwright results → CSV test case deliverable |
 | `sungen-capture` | Acquire visual/design context — one skill, 4 modes: figma-mcp (Dev Mode MCP), figma-pat (URL → spec_figma.md), live (Playwright MCP scan), local (images in `requirements/ui/`) |
 | `sungen-locale` | Bootstrap i18n — audit selectors, detect locale switch mechanism, generate test-data overlay |
+| `sungen-data-factory` | Standardized test-data — field-type/security catalog, 4-source method, `.overwrite`, blind-spot prompts |
 
-## Workflow (7 AI commands)
+## Workflow (8 AI commands)
 
 | Command | What it does |
 |---|---|
 | `/sungen:add-screen <name> <path>` | Scaffold `qa/screens/<name>/` directories |
 | `/sungen:add-flow <name> [--path <url>]` | Scaffold `qa/flows/<name>/` directories for E2E cross-screen testing |
 | `/sungen:create-test <name>` | Generate `.feature` + `test-data.yaml` (auto-detects screen or flow) |
+| `/sungen:create-data-test <name>` | Generate standardized test-data (valid/boundary/invalid + CHK trace) from the Data Factory catalog; no name = all units (asks to confirm) |
 | `/sungen:review <name>` | Score syntax, coverage, viewpoint quality (auto-detects screen or flow) |
 | `/sungen:run-test <name>` | Generate `selectors.yaml`, compile, run, auto-fix (auto-detects screen or flow) |
 | `/sungen:delivery [name...]` | Export test cases → CSV for QA delivery (all screens if no arg) |

package/src/orchestrator/templates/ai-src/config/copilot.md

@@ -18,14 +18,16 @@ You generate 3 files for sungen — a Gherkin compiler that produces Playwright
 | `sungen-delivery` | Export Gherkin + Playwright results → CSV test case deliverable |
 | `sungen-capture` | Acquire visual/design context — one skill, 4 modes: figma-mcp (Dev Mode MCP), figma-pat (URL → spec_figma.md), live (Playwright MCP scan), local (images in `requirements/ui/`) |
 | `sungen-locale` | Bootstrap i18n — audit selectors, detect locale switch mechanism, generate test-data overlay |
+| `sungen-data-factory` | Standardized test-data — field-type/security catalog, 4-source method, `.overwrite`, blind-spot prompts |
 
-## Workflow (7 AI commands)
+## Workflow (8 AI commands)
 
 | Command | What it does |
 |---|---|
 | `/sungen-add-screen <name> <path>` | Scaffold `qa/screens/<name>/` directories |
 | `/sungen-add-flow <name> [--path <url>]` | Scaffold `qa/flows/<name>/` directories for E2E cross-screen testing |
 | `/sungen-create-test <name>` | Generate `.feature` + `test-data.yaml` (auto-detects screen or flow) |
+| `/sungen-create-data-test <name>` | Generate standardized test-data (valid/boundary/invalid + CHK trace) from the Data Factory catalog; no name = all units (asks to confirm) |
 | `/sungen-review <name>` | Score syntax, coverage, viewpoint quality (auto-detects screen or flow) |
 | `/sungen-run-test <name>` | Generate `selectors.yaml`, compile, run, auto-fix (auto-detects screen or flow) |
 | `/sungen-delivery [name...]` | Export test cases → CSV for QA delivery (all screens if no arg) |

package/src/orchestrator/templates/ai-src/skills/sungen-data-factory/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: sungen-data-factory
+description: 'Use when create-data-test (or create-test) needs standardized TEST DATA — valid/boundary/invalid values for input fields with CHK-* traceability. Drives the Data Factory catalog + the 4-source method. Invoke after reading spec.md, when authoring the field-map or filling test-data.'
+user-invocable: false
+---
+
+## What this skill does
+
+Turn a screen/flow's fields into **standardized test data** — not guessed values. You author a
+**field-map**; the deterministic `sungen data gen` expands it from the Data Factory **catalog**
+(field-type + security + technique library) into valid / boundary / invalid values, each carrying a
+`CHK-*` id that traces to the spec. Your judgment goes into *reading the spec correctly* and
+*answering blind spots* — never into inventing values the catalog or the QA should own.
+
+Data Factory is **bundled with core** (runtime-free) — no `capability add` needed; the `sungen data …`
+CLI is available out of the box.
+
+## The 4-source method (phuong-phap-tao-test-data.md)
+
+Never invent values from memory. Cross-reference four sources — each covers the previous one's gap:
+
+1. **Spec validate rules** — required, format, min/max, business rules, and the **error/message code**
+   per rule. Defines the legal/illegal boundary. (Says the *law*, not every way to *break* it.)
+2. **Field-type catalog** — the accumulated "how this type breaks" knowledge (email/password/phone/
+   number/…). This is the Data Factory `common/` — it fills the "spec doesn't list every break" gap.
+3. **Design technique** — Boundary Value Analysis / Equivalence Partitioning / Decision Table / State
+   Transition — reduces the rule + candidates to a *minimal-but-sufficient* representative set.
+4. **DB mapping** — unique constraints, cross-entity dependency, real backend limits → precondition
+   data, not just a single input value.
+
+Then classify every value into **Valid / Boundary / Invalid** (each invalid tagged with its error
+code) and give it a `CHK-*` id for traceability.
+
+## The field-map — `qa/data-factory/<name>.fields.yaml`
+
+Your main artifact. One entry per input field; the generator expands it:
+
+```yaml
+screen: login                 # or  flow: <name>
+fields:
+  - name: email
+    type: email               # a catalog field-type (see list below)
+    required: true
+    constraints: { maxLocal: 64, maxTotal: 254 }   # the project's REAL limits from spec
+    errorMap: { M13: E1042, M02: E1001 }            # catalog placeholder code → project's real code
+  - name: password
+    type: password
+    constraints: { minLength: 8, maxLength: 32 }
+```
+
+**Catalog field-types** (P1): `email` · `password` · `phone` · `string` · `number-integer` ·
+`number-float` · `currency` · `postcode` · `katakana` (JP). Security payload banks auto-append to a
+field's invalid group via the type's `uses_security` (`sqli`, `xss`, `idor`, `broken-auth`, `upload`,
+`input-validation`).
+
+Rules:
+- Pick the closest `type`; put the project's real numbers in `constraints` (they override the
+  catalog defaults).
+- Map every `errorRef` placeholder (`M13`, `M39`, …) to the spec's real code via `errorMap`. Leave
+  one unmapped **only** if the spec has none — the lint flags it as an open point to confirm.
+- **Complex forms:** a **group** field takes nested **`fields:`** (recursive; no `type` on the group → renders a nested object like `address.city`). A field whose rule depends on another takes **`dependsOn: { field, value }`** — recorded as a `_depends_on` note (the generator doesn't resolve the runtime condition; weave it into the scenario/`@cases`).
+- Set **`unique: true`** on a field that must be fresh every run (register email/username, anything
+  that would clash with a record a previous run left behind). Its valid value then carries a runtime
+  `{{$timestamp}}` (email → `user+{{$timestamp}}@…`) so each run is unique — no cross-run cache
+  (which would make tests order-dependent/flaky). Prefer this over caching prior-run values. For
+  reusing a value produced earlier **within the same run** (register → then log in with it), bind it
+  via the scenario (`@dataFactory` recipe / `testData.bind`), not a cross-run cache.
+
+## No input fields → nothing to generate
+
+Data Factory standardizes **field-level input data**. If a unit has no user-input fields or
+parameters — a pure navigation, listing, or capture-compare flow — there is nothing to generate.
+Report *"no input fields → nothing to generate"* and skip it; do **not** write an empty field-map.
+Those scenarios are covered by the data create-test already produced, not by field-level test data.
+(This is a correct outcome, not a gap — don't force a field-map to make the unit "processed".)
+
+## Blind spots — ask, never fabricate
+
+If a field's type is **not** in the catalog — a business enum, a cross-entity constraint, a
+project-specific data model — do **not** guess. Ask the QA (via `AskUserQuestion`) for: (1) the valid
+set, (2) invalid / non-existent values, (3) the error code when wrong, (4) dependencies on other
+fields. Record it in `qa/data-factory/project/<entity>.yaml` so it becomes reusable project catalog.
+This is the core discipline: *common is never enough; when blind, think and ask — don't invent.*
+
+## Customizing the catalog — `.overwrite` (survives `sungen update`)
+
+The shipped `common/` is a floor. Project rules go in `qa/data-factory/common.overwrite.yaml`,
+deep-merged over the common (**later-wins**, keyed by `type` + data-point `id`): same `id` replaces,
+new `id` appends, `constraints` merge key-by-key. `sungen update` refreshes `common/` but never
+touches your overlay. If an update makes an overlay entry stale (references a bank/constraint that no
+longer exists), the loader **warns you to prune it** — it never edits your file. Prefer a targeted
+`errorMap`/`constraints` in the field-map for per-screen tweaks; use `.overwrite` only for rules that
+apply project-wide.
+
+## Bulk-import fixtures (CSV)
+
+For CSV/Excel import or bulk-upload testing, `sungen data fixture --screen <name> [--rows N] [--invalid]`
+turns the field-map into a fixture FILE under `qa/fixtures/`: `<name>.csv` (N valid rows; nested groups
+→ dotted headers; `unique` fields row-indexed) that should import cleanly, and — with `--invalid` —
+`<name>.invalid.csv` (one seeded-bad row per field + a `_violation` column) for row-level rejection
+tests. Reference it from an `@api` upload (`files:`) or a UI file input.
+
+## Verify before done — the phuong-phap §6 checklist
+
+Run `sungen data lint` and clear it: every required field has **≥1 valid**, **boundary present**
+(exact min/max, not only over-boundary) for bounded types, **≥1 invalid per rule** (not one generic
+"wrong" value for many rules), no `UNRESOLVED` values, error codes mapped or explicitly left open.
+Then `sungen data gen` writes the standardized `test-data/<name>.yaml`. Do not hand-edit the
+generated values — change the field-map or `.overwrite` and re-run (determinism: same input → same
+data).
+
+## Weaving into scenarios
+
+When a `.feature` exists, express invalid/boundary sets as data-driven `Scenario Outline` + `Examples`
+(`@cases`) referencing the values — see `sungen-gherkin-syntax`. This keeps one logic + many values
+instead of copy-pasted scenarios, and each row carries its `CHK-*` id for traceability.

package/src/orchestrator/templates/ai-src/skills/sungen-tc-generation/SKILL.md

@@ -6,6 +6,7 @@ user-invocable: false
 
 ## ⚠️ Gotchas — read before generating
 
+- **Field-level test-data follows the Data Factory standard — don't hand-invent values.** When the unit has input fields, the field values (valid / boundary / invalid + error codes) come from the **`sungen-data-factory`** catalog via a field-map + `sungen data gen` (create-test step 5.3), not free-form guessing. Weave the standardized boundary/invalid sets into `@cases` with `CHK-*` trace. This skill still owns scenario structure, viewpoints, and non-field oracles.
 - **Write incrementally — never emit the whole suite in one response.** Build the `.feature` in batches via successive `Write`/`Edit` (≈10–15 scenarios per call). For **Full coverage**, write tier-by-tier: `Write` Tier 1 → `Edit` append Tier 2 → `Edit` append Tier 3.
   → One huge `Write` can exceed the model's output-token cap → `API Error: Claude's response exceeded the N output token maximum`. Single-pass full coverage only fits when `CLAUDE_CODE_MAX_OUTPUT_TOKENS ≥ 64000`; otherwise batch. Batching also lets the audit/reviewer run per batch — higher quality.