@sun-asterisk/sungen 3.0.0-beta.74 → 3.0.0-beta.75

package/src/harness/sensors.ts

@@ -277,3 +277,192 @@ export function traceability(scenarios: ScenarioInfo[], viewpoints: ViewpointEnt
       : 'Traceable.',
   };
 }
+
+// ---------- Claim-Proof (harness-roadmap §0.5 Q1) ----------
+//
+// A scenario's TITLE makes a claim; its STEPS must prove it. This is the
+// design-layer sibling of script-check's anti-bypass (code↔Gherkin): here it is
+// title↔steps. We only measure scenarios whose title carries a claim keyword, so
+// plain visibility/navigation scenarios are never falsely pressured. @manual
+// scenarios are skipped — their claim is deferred to a flow (XS/flow-check owns it).
+
+export interface ClaimUnproven {
+  name: string;
+  claim: string;       // the claim keyword matched in the title
+  need: string;        // the assertion shape the steps must contain
+  hint: string;        // how to fix
+  severity: 'fail' | 'warn';
+}
+
+export interface ClaimProofResult {
+  total: number;        // non-manual scenarios
+  withClaims: number;   // scenarios whose title carries a claim
+  proven: number;
+  unproven: ClaimUnproven[];
+  ratio: number;        // proven / withClaims (1 if withClaims === 0)
+  focus: string;
+  threshold: number;
+  verdict: DepthVerdict;
+}
+
+interface ClaimRule {
+  claim: string;
+  title: RegExp;        // claim keyword(s) in the title
+  proof: RegExp;        // required assertion shape in the steps
+  need: string;
+  hint: string;
+  severity: 'fail' | 'warn';
+  // Optional: even when `proof` matches, if `underproof` also matches the proof is
+  // PARTIAL (the right shape exists but on the wrong/another element) → a warn-level
+  // finding. e.g. an "each card exposes <action>" claim that has a see-all on price
+  // but asserts the actions with singular presence.
+  underproof?: RegExp;
+  underNeed?: string;
+  underHint?: string;
+}
+
+// Ordered by specificity; the first matching rule per scenario wins.
+const CLAIM_RULES: ClaimRule[] = [
+  {
+    claim: 'all/every/each',
+    title: /\b(all|every|each)\b/,
+    proof: /\bsee all\b/,
+    need: 'a `User see all …` assertion (every element, not one)',
+    hint: 'assert across all matched elements — for per-card structure use the all-card DSL (roadmap Q2).',
+    severity: 'fail',
+    // singular action presence under an "each/every" claim = partial proof
+    underproof: /\bsee \[[^\]]+\] (link|button)\b/,
+    underNeed: 'an all-card assertion for the claimed action (not single presence)',
+    underHint: 'the actions are asserted once, not per-card — wrap them with the all-card DSL `User see all [Card] contain [Action]` (roadmap Q2).',
+  },
+  {
+    claim: 'only/belong-to',
+    title: /\b(only|belongs? to|exclusively)\b/,
+    proof: /\bsee all\b[^.]*\bcontain/,
+    need: 'all-match (`User see all … contains …`)',
+    hint: 'all displayed items must match the facet; "no items OUTSIDE" is UI-limited → verify via hybrid API/DB or mark @manual with reason.',
+    severity: 'warn',
+  },
+  {
+    claim: 'single/exactly-one',
+    title: /\b(a single|single|exactly one|just one|only one)\b/,
+    proof: /\bcount\b|\btable with\b|\bexactly\b|tohavecount/,
+    need: 'a count assertion (e.g. count is 1)',
+    hint: 'assert the quantity, not just presence.',
+    severity: 'fail',
+  },
+  {
+    claim: 'correct/matching/identity',
+    title: /\b(correct|matching|the same|same (product|name|price|value|item)|consistency|identity|lands? in|is the (product|item))\b/,
+    proof: /\bremember\b/,
+    need: 'capture + compare (`User remember … as {{v}}` then assert {{v}})',
+    hint: 'remember the value on the source, then assert it on the target (cross-screen → defer to a flow as @manual).',
+    severity: 'fail',
+  },
+  {
+    claim: 'changes/toggles',
+    title: /\b(changes?|toggles?|updates?|reflects?|reopens?)\b/,
+    proof: /\bremember\b|\bis hidden\b/,
+    need: 'a state delta (before ≠ after, or a visible→hidden contrast)',
+    hint: 'capture the before-state and assert the after-state differs, or assert the visible/hidden transition.',
+    severity: 'warn',
+  },
+  {
+    claim: 'hidden/rejected/not-complete',
+    title: /\b(hidden|closed|dismiss(es|ed)?|does not|doesn't|not complete|rejected|inert)\b/,
+    proof: /\bis hidden\b|\bare hidden\b|message is hidden|not complete|\bhidden\b/,
+    need: 'a negative / hidden assertion (`… is hidden`)',
+    hint: 'assert the absence/hidden state that the title claims, not just an unrelated visible element.',
+    severity: 'fail',
+  },
+];
+
+// ---------- Viewpoint taxonomy-lint (harness-roadmap §0.5 Q3) ----------
+//
+// A scenario's VP-code prefix (VP-CART-001 → CART) should match what the title is
+// actually about, or the coverage matrix / per-viewpoint score is skewed. Conservative:
+// flag ONLY when the title carries NO signal for its own category AND exactly one OTHER
+// known category's signal — so a legitimately mixed title (e.g. a LIST card that also
+// mentions an action) is never flagged. LOGIC/UI are flexible lenses → not linted.
+
+export interface TaxonomyFinding {
+  name: string;
+  current: string;   // category from the VP code
+  suggested: string; // category the title signals
+  signal: string;    // the phrase that triggered the suggestion
+}
+
+export interface TaxonomyResult {
+  total: number;
+  checked: number;          // scenarios with a known, lintable category
+  mislabeled: TaxonomyFinding[];
+}
+
+const TAXONOMY_KNOWN = new Set(['LIST', 'PRODUCT', 'CART', 'FILTER', 'NAV', 'VAL', 'SEC']);
+
+const CATEGORY_SIGNALS: { cat: string; re: RegExp }[] = [
+  { cat: 'FILTER', re: /\b(categor(y|ies)|sub-?categor\w*|expand\w*|collaps\w*|\bfacet\b|filter\w*|belongs? to)\b/ },
+  { cat: 'CART', re: /\b(add(ed|ing)? to cart|added (dialog|modal|message|confirmation)|cart (page|table|line|item)|view cart|continue shopping|quantit)\b/ },
+  { cat: 'PRODUCT', re: /\b(product detail|product-detail|view product|product page|same product|product name and price|product identity|detail product)\b/ },
+  { cat: 'LIST', re: /\b(product (list|grid)|featured product|product card|each (featured )?card|every (featured )?card)\b/ },
+  { cat: 'NAV', re: /\b(navigates?|returns the user|redirect\w*|logo returns|menu navigates)\b/ },
+  { cat: 'VAL', re: /\b(valid email|invalid\b|without (a |an )?@|without a domain|empty (email|input|field)|validation|required field)\b/ },
+  { cat: 'SEC', re: /\b(xss|sql|injection|payload|without authentication|unauthenticated|\binert\b|tamper\w*|malformed|url parameter|query param\w*|falls? back|gracefull?y|without a crash|not[- ]found|\b404\b|special character|abuse)\b/ },
+];
+
+export function taxonomyLint(scenarios: ScenarioInfo[]): TaxonomyResult {
+  const mislabeled: TaxonomyFinding[] = [];
+  let checked = 0;
+  for (const s of scenarios) {
+    const cat = s.category;
+    if (!cat || !TAXONOMY_KNOWN.has(cat)) continue;
+    checked++;
+    const title = s.name.toLowerCase();
+    const matched = [...new Set(CATEGORY_SIGNALS.filter((c) => c.re.test(title)).map((c) => c.cat))];
+    if (matched.includes(cat)) continue;             // title supports its own category → fine
+    const others = matched.filter((c) => c !== cat);
+    if (others.length === 1) {                        // unambiguous mismatch
+      const sig = CATEGORY_SIGNALS.find((c) => c.cat === others[0])!;
+      const m = title.match(sig.re);
+      mislabeled.push({ name: s.name, current: cat, suggested: others[0], signal: m ? m[0] : others[0] });
+    }
+  }
+  return { total: scenarios.length, checked, mislabeled };
+}
+
+export function claimProof(scenarios: ScenarioInfo[], focus = 'functional'): ClaimProofResult {
+  const measured = scenarios.filter((s) => !s.manual);
+  const unproven: ClaimUnproven[] = [];
+  let withClaims = 0;
+
+  for (const s of measured) {
+    const title = s.name.toLowerCase();
+    const rule = CLAIM_RULES.find((r) => r.title.test(title));
+    if (!rule) continue;          // no claim → not measured
+    withClaims++;
+    if (!rule.proof.test(s.stepsText)) {
+      // proof shape entirely absent → fail at the rule's severity
+      unproven.push({ name: s.name, claim: rule.claim, need: rule.need, hint: rule.hint, severity: rule.severity });
+    } else if (rule.underproof && rule.underproof.test(s.stepsText)) {
+      // right shape exists but only as a partial proof → warn
+      unproven.push({
+        name: s.name, claim: rule.claim,
+        need: rule.underNeed ?? rule.need,
+        hint: rule.underHint ?? rule.hint,
+        severity: 'warn',
+      });
+    }
+  }
+
+  const proven = withClaims - unproven.length;
+  const ratio = withClaims ? proven / withClaims : 1;
+  const threshold = DEPTH_THRESHOLDS[focus] ?? DEPTH_THRESHOLDS.functional;
+
+  const hasFail = unproven.some((u) => u.severity === 'fail');
+  let verdict: DepthVerdict = 'pass';
+  if (ratio < threshold) {
+    verdict = WARN_ONLY_FOCUS.has(focus) || !hasFail ? 'warn' : 'fail';
+  }
+
+  return { total: measured.length, withClaims, proven, unproven, ratio, focus, threshold, verdict };
+}

package/src/orchestrator/templates/ai-instructions/claude-skill-gherkin-syntax.md

@@ -74,6 +74,18 @@ User switch to [T] frame | [main] frame
 # 8. Page: User see [T] page
 ```
 
+### Collection / all-card (P5)
+
+```
+# Every element's TEXT matches a value (filter correctness, all items belong):
+User see all [Result Product Name] text contains {{category_term}}
+# Every CONTAINER holds a CHILD element (structural per-card proof — prove "each card has X"):
+User see all [Product Card] contain [Product Name]
+User see all [Product Card] contain [Add To Cart] button
+```
+
+Use the all-card form whenever a title claims *every / each* card/row exposes something — a single `User see [Add To Cart] button` does NOT prove "each card" and the harness Claim-Proof gate will flag it.
+
 ### Table
 
 ```

package/src/orchestrator/templates/ai-instructions/github-skill-sungen-gherkin-syntax.md

@@ -74,6 +74,18 @@ User switch to [T] frame | [main] frame
 # 8. Page: User see [T] page
 ```
 
+### Collection / all-card (P5)
+
+```
+# Every element's TEXT matches a value (filter correctness, all items belong):
+User see all [Result Product Name] text contains {{category_term}}
+# Every CONTAINER holds a CHILD element (structural per-card proof — prove "each card has X"):
+User see all [Product Card] contain [Product Name]
+User see all [Product Card] contain [Add To Cart] button
+```
+
+Use the all-card form whenever a title claims *every / each* card/row exposes something — a single `User see [Add To Cart] button` does NOT prove "each card" and the harness Claim-Proof gate will flag it.
+
 ### Table
 
 ```