@sun-asterisk/sungen 3.2.33 → 3.2.34-beta.1

package/src/generators/test-generator/code-generator.ts

@@ -10,6 +10,7 @@ import { capabilityRegistry } from '../../capabilities/registry';
 import { discoverAndRegisterCapabilities } from '../../capabilities/discover';
 import { readCapabilities } from '../../harness/capability';
 import { parseManualComments } from '../../exporters/scenario-merger';
+import { isPresencePlaceholderHybrid } from '../../exporters/manual-hybrid-oracle';
 import { findSyntaxError } from './utils/spec-syntax-check';
 
 /** One capability-injected precondition statement (`@api:`/`@query:` → `testData.bind(name, …)`). */
@@ -790,11 +791,18 @@ export class CodeGenerator {
         //    labeled `Observable:`/`Oracle:`/`Expected:` line (parseManualComments — the
         //    SAME parser delivery uses). Field finding (student-site, 87 scenarios): prose
         //    paragraphs and rationale-only comments exported EMPTY Steps + Expected cells.
+        //  • HAS a Then, but every assertion is a bare presence placeholder while the real oracle
+        //    sits in the comments (#810) — the same banned hybrid wearing a Then: the deliverable
+        //    reads "See [X] table" and a tester ticking it Passed records a check nobody made.
         const isStructured = scenario.steps.length > 0;
         if (isStructured && !hasThenStep(scenario)) {
           this.diagnostics.add('SG-W008',
             `@manual scenario "${scenario.name}" has Gherkin steps but no Then — a When without Then is invalid Gherkin. Add the Then step, or remove the steps and write the full procedure (action steps, then "Observable:"/"Oracle:" lines) in its \`# Tester verifies:\` block`,
             { feature: feature.name, step: scenario.name });
+        } else if (isStructured && isPresencePlaceholderHybrid(scenario.steps, scenario.comments ?? [])) {
+          this.diagnostics.add('SG-W008',
+            `@manual scenario "${scenario.name}" asserts only presence (e.g. "User see [X] table") while its real oracle sits in the \`# Tester verifies:\` comment — the deliverable's Expected would not say what the case checks. Write the oracle as the Then step (e.g. \`table match data:\`), or remove the steps and write the full numbered procedure ("1. <action>" … "N. Observable: <what>")`,
+            { feature: feature.name, step: scenario.name });
         } else if (!isStructured) {
           const parsed = parseManualComments(scenario.comments ?? []);
           if (!parsed.steps.length || !parsed.expected.length) {
@@ -880,7 +888,7 @@ export class CodeGenerator {
       authGroupMap.get(key)!.push(code);
     }
 
-    const authGroups = groupOrder.map(key => ({
+    const authGroups = groupOrder.map((key): { authRole?: string; noAuth: boolean; scenarios: string[]; afterEach?: string } => ({
       authRole: key === NO_AUTH_GROUP_KEY ? undefined : (key || undefined),
       noAuth: key === NO_AUTH_GROUP_KEY,
       scenarios: authGroupMap.get(key)!,
@@ -923,6 +931,19 @@ export class CodeGenerator {
     }
     const scenarios = renderedScenarios.map(s => s.code);
 
+    // #815 — a feature-level `@afterEach` used to sit in the outermost describe, so it also ran after
+    // every `@no-auth` test, on an EMPTY session: a hook that needs the signed-in page (`Given User is
+    // on [probe] page` → redirected to /login) failed an anonymous test whose own steps passed. When
+    // the feature mixes `@no-auth` with any other group, the hook moves INTO each other group and the
+    // no-auth group runs without it. A feature that is anonymous throughout keeps the hook — it was
+    // written for those tests.
+    // (A no-auth group beside another one means ≥2 groups, so `renderAuthBlocks` is already true.)
+    const afterEachInGroups = !!afterEach
+      && authGroups.some(g => g.noAuth) && authGroups.some(g => !g.noAuth);
+    if (afterEachInGroups) {
+      for (const g of authGroups) if (!g.noAuth) g.afterEach = afterEach;
+    }
+
     // For single group, extract the auth role to put test.use at describe level. Keyed on
     // `renderAuthBlocks`, not `needsGrouping`: a lone `@no-auth` group now renders its own block, so
     // hoisting anything to the feature describe would double up. Its authRole is undefined anyway.
@@ -1019,7 +1040,7 @@ export class CodeGenerator {
       featureDescription: feature.description,
       background,
       beforeAll,
-      afterEach,
+      afterEach: afterEachInGroups ? undefined : afterEach,
       afterAll,
       cleanupConfig,
       screenshotOnFailure,

package/src/generators/test-generator/diagnostics.ts

@@ -24,7 +24,9 @@
  *   SG-W008 — @manual scenario is incomplete in either direction: Gherkin steps without a
  *             Then (invalid Gherkin; comments cannot substitute), or a documentation-style
  *             manual (no steps) whose comments lack the extractable procedure — ≥1 numbered
- *             action line + ≥1 labeled Observable:/Oracle:/Expected: line
+ *             action line + ≥1 labeled Observable:/Oracle:/Expected: line — or a Then that
+ *             asserts only presence while the real oracle sits in a `# Tester verifies:`
+ *             comment (#810)
  *   SG-W009 — test-data references a `${QA_*}` secret that is declared in neither .env.qa
  *             nor .env.qa.example — the test will throw "not set" the moment the key is used
  *   SG-W010 — a row step's [Ref] looks POSITIONAL (First/Last/Top/…) but has no selectors.yaml

package/src/harness/audit.ts

@@ -32,7 +32,11 @@ const MULTI_SCREEN_RISK_COUNT = MULTI_SCREEN_RISKS.length;
 import { capabilityRegistry } from '../capabilities/registry';
 import { discoverAndRegisterCapabilities } from '../capabilities/discover';
 import { contextRouter } from '../capabilities/context-router';
-import { readTextFile } from './read-text';
+import { readTextFile, readViewpointText } from './read-text';
+import { isAiDraft } from './viewpoint-draft-header';
+import { viewpointReviewOpenFindings } from './viewpoint-review-open';
+import { uiInventoryCoverage, uiInventoryFindings, UiInventoryResult } from './ui-inventory';
+import { defectLinkFindings } from './defects';
 
 export interface AuditReport {
   screen: string;
@@ -57,6 +61,8 @@ export interface AuditReport {
   flowQuality?: FlowQualityResult;      // #569 — flow contract verification (flows only)
   /** #595 — coverage per DECLARED FLOW; absent when the contract declares no `flows:`. */
   flowInventory?: InventoryResult;
+  /** #811 — design items vs the suite; present only when the unit holds design sources. */
+  uiInventory?: UiInventoryResult;
   calibration: {                // #8 — multi-axis score so a high overall can't hide a weak axis
     axes: Record<string, number>;
     weakest: { axis: string; value: number };
@@ -185,6 +191,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   const scoringCap = scoringCapId ? capabilityRegistry.get(scoringCapId) : undefined;
   const catalog = (scoringCap?.viewpoints?.() as Catalog | undefined) || loadCatalog();
   const spec = specCoverage(specPath, scenarios, featureText);
+  const uiInv = uiInventoryCoverage(path.join(screenDir, 'requirements'), featureText);
 
   // P3 — intent profile from qa/context.md drives the depth threshold (focus).
   const intent = readIntent(projectRootFromScreenDir(screenDir));
@@ -196,7 +203,10 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // Is the declaration this suite is measured against still the one a human accepted?
   const viewpointBaseline = checkViewpointBaseline(
     projectRootFromScreenDir(screenDir), catalogScreenName, viewpointPath);
-  const viewpointText = fs.existsSync(viewpointPath) ? readTextFile(viewpointPath) : '';
+  const viewpointText = readViewpointText(viewpointPath);
+  // `drafted-by: ai` — unreviewed until `--accept-viewpoint` removes it. Only a draft that declares ids
+  // has anything to accept; an id-less one is VIEWPOINT-MISSING's to report, not a dead-end finding.
+  const aiDraft = isAiDraft(viewpointText) && viewpointBaseline.status !== 'absent';
   // #569 — a flow WITH a contract is measured against ITS declaration, not a screen's.
   // Keyword page-type detection force-fit flows into screen checklists (a registration
   // flow judged as a `form` screen scored coverage 0%), so for contract-holding flows the
@@ -211,9 +221,13 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     ? { ...catalog, page_types: {} } as Catalog
     : catalog;
   const capGate = scoringCap?.gateProvider as
-    ((i: { scenarios: ScenarioInfo[]; viewpoints: ViewpointEntry[]; catalog: Catalog; focus: typeof intent.focus; cwd: string; screenName: string; threshold: number; businessCriticalMethods?: string[] }) => { gate: GateResult; depth: DepthResult }) | undefined;
-  const provided = capGate?.({ scenarios, viewpoints, catalog: gateCatalog, focus: intent.focus, cwd: projectRootFromScreenDir(screenDir), screenName: catalogScreenName, threshold: depthThresholdFor(intent.focus), businessCriticalMethods: intent.businessCriticalMethods });
-  const gate = provided?.gate ?? viewpointGate(scenarios, viewpoints, gateCatalog, platform === 'mobile', viewpointText);
+    ((i: { scenarios: ScenarioInfo[]; viewpoints: ViewpointEntry[]; catalog: Catalog; focus: typeof intent.focus; cwd: string; screenName: string; threshold: number; businessCriticalMethods?: string[]; isMobile: boolean; viewpointText: string }) => { gate: GateResult; depth: DepthResult }) | undefined;
+  // The capability gate gets the SAME isMobile + viewpoint text as the in-core fallback, or a declared
+  // `page-type:` is ignored wherever driver-ui scores — every web project, and a mobile project whose
+  // CLI cannot resolve driver-mobile (#864).
+  const isMobile = platform === 'mobile';
+  const provided = capGate?.({ scenarios, viewpoints, catalog: gateCatalog, focus: intent.focus, cwd: projectRootFromScreenDir(screenDir), screenName: catalogScreenName, threshold: depthThresholdFor(intent.focus), businessCriticalMethods: intent.businessCriticalMethods, isMobile, viewpointText });
+  const gate = provided?.gate ?? viewpointGate(scenarios, viewpoints, gateCatalog, isMobile, viewpointText);
   const depth = provided?.depth ?? assertionDepth(scenarios, dataThemesFor(gateCatalog, gate.pageType), intent.focus);
 
   // TQ-4 — deferral-aware coverage credit: an inherently cross-screen theme (cart / detail /
@@ -342,7 +356,8 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // so it can only measure what their author already thought of. One field run wrote the file
   // after generating the suite and said so in its own header — and both axes still read 100%,
   // because a first audit records the baseline silently (#622). Untrusted until a human accepts it.
-  const viewpointMoved = viewpointBaseline.status === 'changed' || adoptedPostHoc;
+  // An AI draft rides the same hold: its line is only removed when a human accepts it.
+  const viewpointMoved = viewpointBaseline.status === 'changed' || adoptedPostHoc || aiDraft;
   // #618 — is there a YARDSTICK at all? `atomicLedger` and `traceability` are both measured
   // against test-viewpoint.md, and four more sensors read it (the ledger, the declaration-integrity
   // checks, the browser-gesture check, the continuity check). When the file is absent every one of
@@ -373,7 +388,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     { key: 'atomicLedger', value: ledger.ratio, weight: 0.13, applicable: ledger.hasViewpoint && ledger.total > 0 && !viewpointMoved, critical: true, withheld: viewpointMoved && ledger.hasViewpoint && ledger.total > 0 },
     { key: 'businessDepth', value: businessDepth, weight: 0.20, applicable: true, critical: true },
     { key: 'claimProof', value: claim.ratio, weight: 0.15, applicable: claim.withClaims > 0, critical: true },
-    { key: 'traceability', value: traceScore, weight: 0.09, applicable: viewpoints.length > 0 && !viewpointMoved, critical: false, withheld: viewpointMoved && viewpoints.length > 0 },
+    { key: 'traceability', value: traceScore, weight: 0.09, applicable: viewpoints.length > 0 && scenarios.length > 0 && !viewpointMoved, critical: false, withheld: viewpointMoved && viewpoints.length > 0 && scenarios.length > 0 },
     // A use-case decomposition is EF-heavy by construction (1 basic flow, N alternates, N
     // exceptions) — that is the shape of a well-decomposed use case, not neglected business
     // core. `flowCoverage` already measures whether the journey's phases are covered, so
@@ -585,7 +600,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     findings.push(`COVERED-VIA-FLOW: critical theme "${c.theme}" is not covered on this screen but is deeply covered by flow "${c.flow}" — cross-screen depth correctly owned by the flow, so it is credited (not a screen gap). Verify with \`sungen flow-check\`.`);
   }
   // Verification-scope (advisory): API/DB verification the project's recorded test type never asked for.
-  for (const v of verificationScopeFindings(featureText, fs.existsSync(viewpointPath) ? readTextFile(viewpointPath) : '', capProfile)) {
+  for (const v of verificationScopeFindings(featureText, viewpointText, capProfile)) {
     findings.push(`VERIFICATION-OUT-OF-SCOPE (${v.layer}): this unit ${v.message}`);
   }
   for (const g of gate.gaps) {
@@ -614,9 +629,15 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // #414 — serial-cascade masking: an @serial suite of independent (re-navigating) scenarios hides
   // failures, because Playwright's describe.serial SKIPS everything after the first red. Isolation is
   // the default, so this only fires when @serial was added to a suite that didn't need it.
-  const cascadeN = serialCascadeRisk(featureText, scenarios.length);
-  if (cascadeN) {
-    findings.push(`SERIAL-CASCADE-RISK: this \`@serial\` suite has ${cascadeN} INDEPENDENT scenarios (each re-navigates via Background) that don't need a shared-page sequence. \`describe.serial\` SKIPS every test after the first failure → one early red MASKS the rest as never-run. **Drop \`@serial\`** — the default per-scenario isolation runs every scenario and isolates failures. Keep \`@serial\` only for a genuinely stateful ordered sequence (where scenario N depends on N-1's state).`);
+  // `@serial` is a property of ONE feature file — only that file compiles to `describe.serial` — so
+  // each file is judged on its own text and its own scenarios. The unit-wide text paired one
+  // feature's @serial with another's navigating Background and counted every scenario of the unit,
+  // telling QA to drop @serial from a genuinely ordered 2-scenario feature (#887).
+  for (const file of featureFiles.filter((f) => fs.existsSync(f))) {
+    const cascadeN = serialCascadeRisk(readTextFile(file), scenarios.filter((s) => s.sourceFile === file).length);
+    if (cascadeN) {
+      findings.push(`SERIAL-CASCADE-RISK: the \`@serial\` suite ${path.basename(file)} has ${cascadeN} INDEPENDENT scenarios (each re-navigates via Background) that don't need a shared-page sequence. \`describe.serial\` SKIPS every test after the first failure → one early red MASKS the rest as never-run. **Drop \`@serial\`** — the default per-scenario isolation runs every scenario and isolates failures. Keep \`@serial\` only for a genuinely stateful ordered sequence (where scenario N depends on N-1's state).`);
+    }
   }
   if (flowDepth.stateful && flowDepth.missing.length) {
     // The advice names the collection the CONTRACT declared. It used to say "the cart" whatever
@@ -643,12 +664,19 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   for (const m of taxonomy.mislabeled) {
     findings.push(`VP-MISLABEL: "${m.name}" is coded VP-${m.current} but reads as ${m.suggested} (signal: "${m.signal}") → re-tag VP-${m.suggested}-NNN so the coverage matrix isn't skewed.`);
   }
+  // Scenario ↔ defect record links (qa/defects/) — advisory, never scored.
+  findings.push(...defectLinkFindings(projectRootFromScreenDir(screenDir), catalogScreenName, featureText, scenarios.map((sc) => sc.name)));
   if (balance.unclassifiedRatio > 0.4) {
     findings.push(`TAXONOMY-UNCLASSIFIED: ${balance.note} → align the VP-<CATEGORY> codes with the catalog (or extend the bucket keywords) so coverage-balance is meaningful.`);
   } else if (balance.imbalanced && !flowScored) {
     findings.push(`BALANCE: ${balance.note} Stop expanding secondary viewpoints until business-core gaps are filled.`);
   }
-  if (adoptedPostHoc) {
+  if (aiDraft) {
+    findings.push(`VIEWPOINT-DRAFT-UNREVIEWED: \`requirements/test-viewpoint.md\` is marked \`drafted-by: ai\` and no QA has accepted it, so it is not recorded as the baseline and \`atomicLedger\` + \`traceability\` are held as unverified — a checklist the AI wrote would otherwise score the suite it generated at 100% by construction. QA: review the claims (add what you care about, delete what you do not), then \`sungen audit --screen ${screenName} --accept-viewpoint\` — it records the baseline and removes the \`drafted-by: ai\` line. A QA decision: an agent presents it and does not run it.`);
+  }
+  // create-test's checklist review of the viewpoint, still waiting for QA — advisory, never scored.
+  findings.push(...viewpointReviewOpenFindings(path.dirname(viewpointPath)));
+  if (adoptedPostHoc && !aiDraft) {   // a draft's own finding already says this and names the accept command
     findings.push(`VIEWPOINT-ADOPTED-POST-HOC: this is the first audit of \`requirements/test-viewpoint.md\` and the suite ALREADY has ${scenarios.length} scenarios, so the yardstick is being introduced against tests that already exist. A declaration written after the suite can only measure what its author already thought of — and if it was derived FROM the suite, \`atomicLedger\` and \`traceability\` read 100% by construction while anything dropped along the way stops being missing from anything. Both axes are held as unverified until you review the claims (add what you care about, delete what you do not) and confirm: \`sungen audit --screen ${screenName} --accept-viewpoint\` — a QA decision: an agent presents it and does not run it.`);
   }
   if (!hasYardstick) {
@@ -657,7 +685,8 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
       ...(unsourced.length ? [`${unsourced.length} scenario(s) could not be traced to a source`] : []),
     ];
     findings.push(`VIEWPOINT-MISSING: \`requirements/test-viewpoint.md\` ${ledger.hasViewpoint ? 'declares no viewpoints' : 'does not exist'}, so this unit has no yardstick. Two scored axes are excluded (atomicLedger, traceability) and four sensors cannot run: the atomic ledger, the declaration-integrity checks (reused ids, dangling refs, uniform priority), the browser-gesture check and the two-way continuity check. Nothing here is a pass — it is unmeasured [${lost.join(', ')}]. A flow contract does NOT substitute: the contract declares the use case, the viewpoint declares the CLAIMS the suite is scored against, and only the second is independent of what was generated. Author it (\`sungen add-flow\` scaffolds a template), then \`sungen audit --screen ${screenName} --accept-viewpoint\`.`);
-  } else if (trace.mappedRatio < 0.5) {
+  } else if (scenarios.length > 0 && trace.mappedRatio < 0.5) {
+    // No scenario yet is not a traceability gap — the axis is n/a, like coverage and claimProof (#852).
     findings.push(`TRACE: ${trace.note}`);
   }
   // (UNIVERSAL viewpoint-gap finding now emitted by the `ui` gate sensor — see the gate block below.)
@@ -698,8 +727,10 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   for (const d of downstream.underCovered) {
     findings.push(`DOWNSTREAM-SCOPE-MISSING: "${d.route}" is a navigation target but is covered only by a page-nav assertion — cover its content/guards, or scaffold it (\`sungen add --screen ${d.slug}\`).`);
   }
+  // #811 — design inventory (advisory): never moves the score or the gate.
+  findings.push(...uiInventoryFindings(uiInv));
   for (const m of manualOracleResult.insufficient.slice(0, 8)) {
-    findings.push(`MANUAL-STEPS-INSUFFICIENT: "${m}" — @manual is incomplete: either Gherkin steps without a Then (invalid Gherkin; comments can't substitute), or a documentation manual whose comments lack numbered action steps + a labeled Observable:/Oracle: line. Write \`# Tester verifies:\` as "1. <action>" … "N. Observable: <what>" / "Oracle: <tool>" — that is what the delivery parser extracts into Steps/Expected.`);
+    findings.push(`MANUAL-STEPS-INSUFFICIENT: "${m}" — @manual is incomplete: either Gherkin steps without a Then (invalid Gherkin; comments can't substitute), a Then that only asserts presence (\`see [X] table\`) while the real oracle sits in a \`# Tester verifies:\` comment (the deliverable's Expected would not say what is checked), or a documentation manual whose comments lack numbered action steps + a labeled Observable:/Oracle: line. Write \`# Tester verifies:\` as "1. <action>" … "N. Observable: <what>" / "Oracle: <tool>" — that is what the delivery parser extracts into Steps/Expected.`);
   }
   // TQ-2 — automatable @manual: deferred (usually cross-screen) but fully DSL-expressible.
   for (const m of autoManual.scenarios.slice(0, 8)) {
@@ -797,7 +828,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   // #622 — the priority table is where release selection comes from; a tag that contradicts it
   // means nobody can tell which of the two was the decision.
   {
-    const pm = priorityMismatches(hasYardstick ? (readText(viewpointPath) ?? '') : '', scenarios);
+    const pm = priorityMismatches(hasYardstick ? viewpoints : [], scenarios);
     const byId = new Map<string, { declared: string; tagged: string; n: number }>();
     for (const m of pm) {
       const cur = byId.get(m.id) ?? { declared: m.declared, tagged: m.tagged, n: 0 };
@@ -870,8 +901,11 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
   axes.manualOracle = Math.round(manualCompleteness * 100) / 100;
   // Only a real mismatch scores 0. Without a yardstick `trace.mappedRatio` is 0 because there is
   // nothing to map to, and reporting that as the weakest axis sent authors to "raise taxonomy" —
-  // an axis that was never measured.
-  if (hasYardstick) axes.taxonomy = taxonomyMismatch ? 0 : Math.round(trace.mappedRatio * 100) / 100;
+  // an axis that was never measured. The same holds for a yardstick the ledger can read but that
+  // declares no viewpoint ID traceability can read (per-axis tables only, #832): the ledger has
+  // items, so `hasYardstick` is true, yet there is still nothing to map to. Same condition as the
+  // `traceability` score axis (`applicable: viewpoints.length > 0`).
+  if (hasYardstick && viewpoints.length > 0 && scenarios.length > 0) axes.taxonomy = taxonomyMismatch ? 0 : Math.round(trace.mappedRatio * 100) / 100;
   const notApplicable = axisDefs.filter((a) => !a.applicable).map((a) => a.key);
   const weakestEntry = Object.entries(axes).sort((a, b) => a[1] - b[1])[0];
   const weakest = { axis: weakestEntry[0], value: weakestEntry[1] };
@@ -899,6 +933,7 @@ export function runAudit(screenDir: string, screenName: string): AuditReport {
     gate, depth, claim, taxonomy, balance, duplicates, trace, spec,
     taxonomyMismatch, reusedScenarioIds: reusedIds, downstream, manualOracle: manualOracleResult, automatableManual: autoManual, flowDepth, oracle, ledger, viewpointBaseline, calibration,
     ...(isUiFlow ? { flowQuality: flowQ, flowInventory: inventory ?? undefined } : {}),
+    ...(uiInv.designSources.length ? { uiInventory: uiInv } : {}),
     score: {
       overall: Math.round(overall * 10) / 10,
       coverage: Math.round(coverage * 100) / 100,

package/src/harness/counted-assertions.ts

@@ -0,0 +1,33 @@
+/**
+ * How many items a scenario's assertions demonstrate — the denominator of CLAIM-PARTIAL (#622).
+ *
+ * One reading for both places that check a counted claim (the viewpoint ledger and the title-level
+ * `numericClaimGaps`), which used to carry their own copy of the regex.
+ *
+ * Counted, once per distinct assertion:
+ *   - a value: `see [X] … with|contains {{v}}`;
+ *   - a positive state: `see [X] … is checked|selected|enabled|disabled`;
+ *   - an indicator's presence: `see [X] icon|checkbox|toggle|radio|badge|image` (#866) — on mobile a
+ *     ticked item is often observable ONLY as its tick icon, so one per item is the proof.
+ * Not counted: plain visibility of text/headers (it shows a label, not one of N values) and absence
+ * (`is hidden`, `not …`), which proves nothing is there.
+ */
+// The tail stops before the NEXT `see [`, or consecutive assertions would swallow each other.
+const SEE_STEP = /\bsee \[([^\]]+)\]((?:(?!\bsee \[)[^[])*)/g;
+const VALUE = /^[^|]*?\b(?:with|contains) (\{\{[^}]*\}\})/;
+const ABSENT = /^\s*\S*\s*(?:is hidden|is not\b|not\b|does not\b)/;
+const STATE = /^\s*\S*\s*is (checked|selected|enabled|disabled)\b/;
+const INDICATOR = /^\s*(icon|checkbox|toggle|radio|badge|image)\b/;
+
+export function countedAssertions(stepsText: string): number {
+  const seen = new Set<string>();
+  for (const m of stepsText.matchAll(SEE_STEP)) {
+    const [, target, rest] = m;
+    if (ABSENT.test(rest)) continue;
+    // Keyed on the target and WHAT it proves — never on the tail, which runs into the next step, so
+    // the same element asserted before and after an action is still one assertion.
+    const proof = VALUE.exec(rest)?.[1] ?? STATE.exec(rest)?.[1] ?? INDICATOR.exec(rest)?.[1];
+    if (proof) seen.add(`${target}|${proof}`);
+  }
+  return seen.size;
+}

package/src/harness/data-driven-lint.ts

@@ -155,29 +155,100 @@ function overrideKeys(raw?: string): Set<string> {
   return out;
 }
 
+interface FeatureUnderLint {
+  /** Feature file basename — names the test-data file the runtime loads for it. */
+  name: string;
+  scenarios: ParsedScenario[];
+  tags: string[];
+}
+
+/** What every feature of a unit shares: unit-level refs and the @api catalog. */
+interface UnitLintContext {
+  screenDir: string;
+  screenName: string;
+  cwd: string;
+  fileRefs: Set<string>;
+  apiParams: Map<string, string[]>;
+}
+
 /** Lint the @cases/@query usage of one screen/flow directory. Returns advisory warnings. */
 export function lintDataDriven(screenDir: string, cwd: string = process.cwd()): DataDrivenWarning[] {
   const base = path.basename(screenDir);
   const screenName = unitIdOf(screenDir);
   // Every `.feature` of the unit — `add --feature` sub-features lint too. A file that
   // fails to parse contributes nothing rather than voiding the whole unit's lint.
-  const scenarios: ParsedScenario[] = [];
-  const featureTags: string[] = [];
-  for (const p of featureFilesFor(screenDir, base).filter((f) => fs.existsSync(f))) {
+  const features: FeatureUnderLint[] = [];
+  const featureFiles = featureFilesFor(screenDir, base).filter((f) => fs.existsSync(f));
+  for (const p of featureFiles) {
     try {
       const feature = new GherkinParser().parseFeatureFile(p);
-      scenarios.push(...(feature.scenarios || []));
-      featureTags.push(...(feature.tags || []));
+      features.push({ name: path.basename(p, '.feature'), scenarios: feature.scenarios || [], tags: feature.tags || [] });
     } catch {
       /* a file that fails to parse contributes nothing */
     }
   }
-  if (scenarios.length === 0) return [];
+  if (!features.some((f) => f.scenarios.length > 0)) return [];
+
+  const ctx: UnitLintContext = {
+    screenDir, screenName, cwd,
+    // `{{key}}` refs carried by the unit's selectors (i18n) and mock catalog are live too.
+    fileRefs: refsInUnitFiles(screenDir),
+    apiParams: apiParamsByName(screenName, cwd),
+  };
+
+  // #839 — each feature against ITS OWN test-data file. The runtime loads
+  // `test-data/<feature file basename>.yaml` (TestDataLoader.load(unit, featureFileName)), with no
+  // fallback and no merging; reading `<unit dir>.yaml` instead found nothing whenever the names
+  // differ — the default for `add --screen x --path /a/b` (→ b.feature) and for `--feature` — so
+  // every key read as missing and no orphan was ever reported. The tables are deliberately NOT
+  // merged: a key in another feature's file compiles to the literal `${key}` here.
+  const warns: DataDrivenWarning[] = [];
+  for (const f of features) if (f.scenarios.length > 0) warns.push(...lintFeature(f, ctx));
+  warns.push(...unloadedTestDataFiles(screenDir, featureFiles.map((f) => path.basename(f, '.feature'))));
+
+  // Catalog-level lint (SELECT-only, params declared/used, datasource present).
+  try {
+    for (const e of lintCatalog(screenName, null, cwd).errors) warns.push({ message: e });
+  } catch {
+    /* no catalog → nothing to lint */
+  }
+  return warns;
+}
+
+/**
+ * A test-data file no feature loads is dead in full: the runtime reads only
+ * `<feature>.yaml` and its `<feature>.<env>.yaml` overlays. Typically a `<unit>.yaml` written by
+ * hand next to a feature `add --path` named after the URL — its keys never reach a test.
+ * Every existing feature file counts (even one that failed to parse), so a parse error never
+ * turns its data into a false "loaded by no feature".
+ */
+function unloadedTestDataFiles(screenDir: string, featureNames: string[]): DataDrivenWarning[] {
+  let files: string[];
+  try {
+    files = fs.readdirSync(path.join(screenDir, 'test-data')).filter((f) => /\.ya?ml$/.test(f) && !f.startsWith('_'));
+  } catch {
+    return [];
+  }
+  const loaded = (stem: string): boolean => featureNames.some((n) => stem === n || stem.startsWith(`${n}.`));
+  return files
+    .filter((f) => !loaded(f.replace(/\.ya?ml$/, '')) || !f.endsWith('.yaml'))
+    .map((f) => ({
+      message: `test-data/${f} is loaded by no feature — the runtime reads test-data/<feature>.yaml (+ <feature>.<env>.yaml) for ${featureNames.map((n) => `${n}.feature`).join(', ')}: move its keys there or remove it.`,
+    }));
+}
 
-  const tdPath = path.join(screenDir, 'test-data', `${base}.yaml`);
-  const td: Record<string, any> = tdPath && fs.existsSync(tdPath) ? parseYaml(fs.readFileSync(tdPath, 'utf8')) || {} : {};
+function lintFeature(feature: FeatureUnderLint, ctx: UnitLintContext): DataDrivenWarning[] {
+  const { screenName, cwd, fileRefs, apiParams } = ctx;
+  const { scenarios, tags: featureTags } = feature;
+  const tdFile = `test-data/${feature.name}.yaml`;
+  const tdPath = path.join(ctx.screenDir, 'test-data', `${feature.name}.yaml`);
+  const td: Record<string, any> = fs.existsSync(tdPath) ? parseYaml(fs.readFileSync(tdPath, 'utf8')) || {} : {};
   const topKeys = new Set(Object.keys(td));
   const warns: DataDrivenWarning[] = [];
+  // H3: an `@extend:<base>` scenario runs the base's steps first — the base's captures bind for it.
+  // Per feature, like the compiler's steps registry: an `@extend` never reaches another file's base.
+  const stepsBase = new Map<string, ParsedScenario>();
+  for (const sc of scenarios) if (sc.stepsName) stepsBase.set(sc.stepsName, sc);
   // Bindings a `@beforeAll` hook's `@api:`/`@query:` preconditions make are readable from EVERY
   // scenario of the feature (the compiler registers them feature-wide). A `remember … as` inside the
   // hook is NOT — it stays hook-local — so only the tag-bound names are exempted here.
@@ -186,18 +257,12 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
     if (sc.hookType !== 'beforeAll') continue;
     for (const t of sc.tags || []) { const m = t.match(/^@(?:api|query):([A-Za-z_]\w*)/); if (m) featureBound.add(m[1]); }
   }
-  // H3: an `@extend:<base>` scenario runs the base's steps first — the base's captures bind for it.
-  const stepsBase = new Map<string, ParsedScenario>();
-  for (const sc of scenarios) if (sc.stepsName) stepsBase.set(sc.stepsName, sc);
-  // `{{key}}` refs carried by the unit's selectors (i18n) and mock catalog are live too.
-  const fileRefs = refsInUnitFiles(screenDir);
   // A feature-level `@manual` makes every scenario manual (the whole file is skipped by the compiler).
   const featureManual = featureTags.some((t) => t === '@manual' || t.startsWith('@manual:'));
 
   // What the scenarios bind, collected up front — the @query pass below adds the params it binds by name.
   const usedHeads = new Set<string>();
   const usedDatasets = new Set<string>();
-  const apiParams = apiParamsByName(screenName, cwd);
   for (const h of fileRefs) usedHeads.add(h);
   for (const sc of scenarios) {
     for (const r of collectRefs(sc, featureManual || isManualScenario(sc))) usedHeads.add(r.split(/[.[]/)[0]);
@@ -228,7 +293,7 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
       const ds = casesTag.slice('@cases:'.length).trim();
       const rows = td[ds];
       if (!Array.isArray(rows)) {
-        warns.push({ scenario: sc.name, message: `@cases:${ds} → dataset "${ds}" is missing or not a list in test-data.` });
+        warns.push({ scenario: sc.name, message: `@cases:${ds} → dataset "${ds}" is missing or not a list in ${tdFile}.` });
       } else {
         const colSets = rows.map((r) => new Set(Object.keys(r || {}).filter((k) => !ROW_META.has(k))));
         const allCols = new Set<string>();
@@ -256,7 +321,7 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
       for (const r of refs) {
         const head = r.split(/[.[]/)[0];
         if (head.startsWith('$') || bound.has(head) || featureBound.has(head) || topKeys.has(head)) continue;
-        warns.push({ scenario: sc.name, message: `{{${r}}} is not a test-data key and nothing binds it at run time — it compiles to the literal text '\${${r}}' (add the key to test-data, or fix the ref).` });
+        warns.push({ scenario: sc.name, message: `{{${r}}} is not a test-data key and nothing binds it at run time — it compiles to the literal text '\${${r}}' (add the key to ${tdFile}, or fix the ref).` });
       }
     }
 
@@ -289,15 +354,8 @@ export function lintDataDriven(screenDir: string, cwd: string = process.cwd()):
   for (const k of topKeys) {
     if (k.startsWith('_')) continue; // Data Factory metadata, not scenario data
     if (!usedHeads.has(k) && !usedDatasets.has(k)) {
-      warns.push({ message: `test-data key "${k}" is defined but never referenced ({{${k}}}, a @cases dataset, or an override) — dead data: bind it into a scenario or remove it.` });
+      warns.push({ message: `test-data key "${k}" is defined but never referenced ({{${k}}}, a @cases dataset, or an override) by ${feature.name}.feature — dead data: bind it into a scenario or remove it from ${tdFile}.` });
     }
   }
-
-  // Catalog-level lint (SELECT-only, params declared/used, datasource present).
-  try {
-    for (const e of lintCatalog(screenName, null, cwd).errors) warns.push({ message: e });
-  } catch {
-    /* no catalog → nothing to lint */
-  }
   return warns;
 }

package/src/harness/defect-draft.ts

@@ -0,0 +1,115 @@
+/**
+ * `sungen defect draft` — turn each `product-candidate` row of a unit's last triage into a record
+ * `qa/defects/DEF-NNN-<slug>.md` (see defects.ts for the link checks). Deterministic: Steps come
+ * from the scenario's Gherkin with test-data resolved, Expected/Actual from the assertion, and the
+ * severity is PROPOSED by rule until QA confirms it. Never overwrites a file, and never drafts a
+ * scenario an existing record already names.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { stringify as toYaml } from 'yaml';
+import type { ResolvedUnit } from '../cli/resolve-unit';
+import { redactSecrets } from '../exporters/api-testcase-formatter';
+import { getEnvironment } from '../exporters/run-environment';
+import { parseFeatureMetadata } from '../exporters/feature-parser';
+import { mergeFeatureAndSpec, MergedScenario } from '../exporters/scenario-merger';
+import { maskCredentialValue } from '../exporters/sensitive-key';
+import { parseSpecFile } from '../exporters/spec-parser';
+import { loadTestData, substituteTestDataVars } from '../exporters/test-data-resolver';
+import { readCapabilities } from './capability';
+import { defectsDir, nextDefectId, readDefects } from './defects';
+import type { TriageRow } from './triage';
+import { readTriageReport, unitSecrets } from './triage-unit';
+
+export interface DraftResult {
+  /** `sungen triage` has not run for this unit. */
+  missingTriage?: boolean;
+  written: string[];
+  skipped: Array<{ scenario: string; id: string }>;
+}
+
+/** Blocking actions: a @high scenario that fails on one of these is `major`, otherwise `minor`. */
+const BLOCKING = /\b(?:submit|save|apply|log ?in|sign ?in|sign ?up|register|checkout|pay|confirm|send|navigate|redirect)\b/i;
+
+const slug = (s: string): string =>
+  s.replace(/^\s*(?:VP|FL)-[A-Z0-9-]+\s+/i, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50).replace(/-$/, '');
+
+interface UnitScenario { merged: MergedScenario; testData: Record<string, string>; secrets: string[] }
+
+/** Scenario title → its merged Gherkin, test-data (credentials masked) and secret values. */
+function unitScenarios(cwd: string, unit: ResolvedUnit): Map<string, UnitScenario> {
+  const out = new Map<string, UnitScenario>();
+  const featuresDir = path.join(unit.dir, 'features');
+  if (!fs.existsSync(featuresDir)) return out;
+  for (const f of fs.readdirSync(featuresDir).filter((x) => x.endsWith('.feature'))) {
+    const base = f.replace(/\.feature$/, '');
+    const spec = parseSpecFile(path.join(cwd, 'specs', 'generated', unit.unitId, `${base}.spec.ts`));
+    const dataFile = path.join(unit.dir, 'test-data', `${base}.yaml`);
+    const raw = fs.existsSync(dataFile) ? loadTestData(dataFile) : {};
+    const testData = Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, maskCredentialValue(k, String(v))]));
+    const secrets = unitSecrets(raw, cwd);
+    for (const m of mergeFeatureAndSpec(parseFeatureMetadata(path.join(featuresDir, f)), spec)) {
+      out.set(m.feature.name, { merged: m, testData, secrets });
+    }
+  }
+  return out;
+}
+
+function render(cwd: string, unit: ResolvedUnit, id: string, row: TriageRow, sc: UnitScenario | undefined): string {
+  const tags = sc?.merged.feature.tags ?? [];
+  const resolve = (t: string): string => (sc ? substituteTestDataVars(t, sc.testData) : t);
+  const steps = (sc?.merged.resolvedSteps ?? []).map((s) => resolve(s.text));
+  const thens = (sc?.merged.resolvedExpected ?? []).map((s) => resolve(s.text));
+  const high = tags.some((t) => t === '@high' || t === '@critical');
+  const severity = high && BLOCKING.test([row.scenario, ...steps].join(' ')) ? 'major' : 'minor';
+  const specFile = path.join(unit.dir, 'requirements', 'spec.md');
+  const env = getEnvironment(cwd);
+  const front = {
+    id, title: row.scenario, severity, severity_source: 'proposed', status: 'open',
+    units: [unit.unitId], scenarios: [row.scenario], claims: row.ids, legacy: row.legacy,
+    spec: fs.existsSync(specFile) ? path.relative(cwd, specFile) : '',
+    found: {
+      date: new Date().toISOString().slice(0, 10),
+      env: process.env.SUNGEN_ENV || 'default',
+      base_url: env.baseURL,
+      platform: row.variant || readCapabilities(cwd).platform || 'web',
+    },
+    tracker: '',
+  };
+  const body = [
+    '---', toYaml(front).trimEnd(), '---', '',
+    `# ${id}: ${row.scenario}`, '',
+    '## Summary', '', '(to fill: what is wrong, where, and who it affects)', '',
+    '## Steps to reproduce', '', ...(steps.length ? steps.map((s, i) => `${i + 1}. ${s}`) : ['(scenario steps not found — see the feature)']), '',
+    '## Expected', '', ...thens.map((t) => `- ${t}`), ...(row.expected ? [`- Asserted value: ${row.expected}`] : []), '',
+    '## Actual', '', `- ${row.received ? `Received: ${row.received}` : row.evidence}`, '',
+    '## Evidence', '', `- Error: ${row.evidence}`, ...(row.tracePath ? [`- Trace: ${row.tracePath}`] : []), '',
+    '## Notes', '', `- Triage: ${row.class} (${row.ruleId})${row.variant ? ` on ${row.variant}` : ''}`, '',
+  ].join('\n');
+  return redactSecrets(body, sc?.secrets ?? []);
+}
+
+export function draftDefects(cwd: string, unit: ResolvedUnit, opts: { scenario?: string } = {}): DraftResult {
+  const triage = readTriageReport(cwd, unit.unitId);
+  if (!triage) return { missingTriage: true, written: [], skipped: [] };
+  const recorded = new Map<string, string>();
+  for (const r of readDefects(cwd)) if (r.units.includes(unit.unitId)) for (const s of r.scenarios) recorded.set(s, r.id);
+
+  const wanted = triage.rows.filter((r) => r.class === 'product-candidate'
+    && (!opts.scenario || r.scenario.includes(opts.scenario) || r.ids.includes(opts.scenario)));
+  const scenarios = unitScenarios(cwd, unit);
+  const result: DraftResult = { written: [], skipped: [] };
+  const seen = new Set<string>();
+  for (const row of wanted) {
+    if (seen.has(row.scenario)) continue;   // one record per scenario, even across OS variants
+    seen.add(row.scenario);
+    const existing = recorded.get(row.scenario);
+    if (existing) { result.skipped.push({ scenario: row.scenario, id: existing }); continue; }
+    const id = nextDefectId(cwd);
+    const file = path.join(defectsDir(cwd), `${id}-${slug(row.scenario) || 'defect'}.md`);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, render(cwd, unit, id, row, scenarios.get(row.scenario)), { encoding: 'utf-8', flag: 'wx' });
+    result.written.push(path.relative(cwd, file));
+  }
+  return result;
+}