@llman-sdd/core 0.3.1 → 0.5.1

package/src/spec/ir.ts

@@ -2,6 +2,12 @@
  * Spec IR (spec-parsing capability): pure data shapes produced by
  * parseCapability() and consumed by validation (Phase 3) and downstream
  * commands. No IO of any kind lives here.
+ *
+ * Native model (v2): a capability feature is `功能:` → `规则:` blocks (the
+ * requirement: title + free-form description + `@req:<id>` handle on the block
+ * header) → nested `场景:` (executable GWT examples). Top-level scenarios that
+ * are not under any rule are orphans. Legacy tags (@human/@rule/@executable)
+ * are inert to parsing; migrate with `spec migrate-native`.
  */
 
 export interface CapabilityHeader {
@@ -10,24 +16,40 @@ export interface CapabilityHeader {
   scope: string | null;
 }
 
-export type ScenarioClassification = 'human' | 'executable' | 'unclassified';
+export type ScenarioStepKind = 'given' | 'when' | 'then';
+
+export interface ScenarioStep {
+  kind: ScenarioStepKind;
+  text: string;
+}
 
 export interface ScenarioIR {
   name: string;
-  /** Tag names without the leading `@`. */
+  /** Non-`@req` tags on this scenario (e.g. `@skip`, `@experimental`). */
   tags: string[];
-  /** `@req:rN` links, normalized to `rN`. */
-  reqIds: string[];
-  classification: ScenarioClassification;
-  /** Rule statement (description lines, trimmed) + step texts for executables. */
-  statement: string;
+  /** Whether the runner should execute this scenario (false for @skip etc.). */
+  runnable: boolean;
   stepCount: number;
-  /** Executable-scenario steps with their keyword kinds (context-index tree). */
-  steps: { kind: 'given' | 'when' | 'then'; text: string }[];
+  steps: ScenarioStep[];
+  /** Step-texts joined (retrieval/context surface); empty for a stepless scenario. */
+  statement: string;
+}
+
+export interface RuleIR {
+  /** The `@req:<id>` handle on the rule block header (global-registry key). */
+  reqId: string;
+  /** The `规则:` block title. */
+  title: string;
+  /** Free-form requirement statement (block description lines, as authored). */
+  description: string;
+  /** Nested executable examples belonging to this rule. */
+  scenarios: ScenarioIR[];
+  /** Non-`@req` tags on the rule block header (legacy @human etc. — inert). */
+  tags: string[];
 }
 
 export interface SpecStructuralError {
-  /** Machine-ish anchor, e.g. `missing-header:purpose` or `scenario:规则样例`. */
+  /** Machine-ish anchor, e.g. `missing-header:purpose` or `scenario:样例`. */
   code: string;
   message: string;
 }
@@ -37,13 +59,19 @@ export interface CapabilityDoc {
   header: CapabilityHeader;
   featureName: string;
   language: string;
-  scenarios: ScenarioIR[];
+  /** Requirement blocks (`规则:`); the canonical rule set. */
+  rules: RuleIR[];
+  /** Top-level scenarios not enclosed by any rule (orphans). */
+  orphans: ScenarioIR[];
   errors: SpecStructuralError[];
 }
 
 /**
- * v1 wording: constraint statements must contain one of these tokens.
- * Shared by the parser (structural error) and validation (verdict gate) so
- * the two MUST-word checks cannot drift apart.
+ * Single spec-id caliber (r25) for every consumer that labels a discovered
+ * spec entry: the `# capability:` header wins, else the fileName minus the
+ * `.feature` suffix. Unifies the former dual caliber (bare `fileName` vs
+ * stripped stem) shared by review/context-tree/specs-report/validate paths.
  */
-export const MUST_WORD_RE = /\bMUST\b|\bSHALL\b|必须|不得|禁止/u;
+export function specIdOf(entry: { fileName: string; doc: CapabilityDoc }): string {
+  return entry.doc.header.capability ?? entry.fileName.replace(/\.feature$/u, '');
+}

package/src/spec/keywords.ts

@@ -0,0 +1,147 @@
+/**
+ * Official Gherkin dialect keyword lookup — the vocabulary SSOT is the
+ * official table shipped with @cucumber/gherkin (`dialects`, i.e.
+ * gherkin-languages.json, 80 dialects). Emitting keywords from anything
+ * else risks mixed-dialect output the official parser rejects.
+ *
+ * Selection policy (deterministic): the official tables list synonyms in an
+ * order that reproduces no contract (en `scenario: ["Example", "Scenario"]`,
+ * zh-CN `rule: ["Rule", "规则"]`), so position heuristics cannot work. The
+ * en and zh-CN contract keywords (r88 — 不得漂移) are pinned explicitly and
+ * MUST be members of their official table (runtime-checked, tests pin the
+ * bytes); every other dialect takes the first non-star synonym.
+ */
+import { dialects, type Dialect } from '@cucumber/gherkin';
+
+export interface GherkinKeywords {
+  feature: string;
+  rule: string;
+  scenario: string;
+  given: string;
+  when: string;
+  thenText: string;
+}
+
+/**
+ * GherkinKeywords keys ↔ official Dialect field keys (thenText ↔ then).
+ */
+const TABLE_KEY_PAIRS = [
+  ['feature', 'feature'],
+  ['rule', 'rule'],
+  ['scenario', 'scenario'],
+  ['given', 'given'],
+  ['when', 'when'],
+  ['then', 'thenText'],
+] as const;
+
+/** Contract-locked keyword bytes (r88) — membership-checked against the table. */
+const LOCKED_KEYWORDS: Record<string, GherkinKeywords> = {
+  en: {
+    feature: 'Feature',
+    rule: 'Rule',
+    scenario: 'Scenario',
+    given: 'Given',
+    when: 'When',
+    thenText: 'Then',
+  },
+  'zh-CN': {
+    feature: '功能',
+    rule: '规则',
+    scenario: '场景',
+    given: '假如',
+    when: '当',
+    thenText: '那么',
+  },
+};
+
+function pickKeyword(entries: readonly string[]): string {
+  return entries.map((k) => k.trim()).find((k) => k !== '' && k !== '*') ?? '';
+}
+
+function keywordsFromTable(table: Dialect): GherkinKeywords | null {
+  const kw: GherkinKeywords = {
+    feature: pickKeyword(table.feature),
+    rule: pickKeyword(table.rule),
+    scenario: pickKeyword(table.scenario),
+    given: pickKeyword(table.given),
+    when: pickKeyword(table.when),
+    thenText: pickKeyword(table.then),
+  };
+  if (Object.values(kw).some((v) => v === '')) return null;
+  return kw;
+}
+
+/** Official keywords for a gherkin dialect, or null when the language has no table. */
+export function officialKeywords(language: string): GherkinKeywords | null {
+  const table = dialects[language];
+  if (!table) return null;
+  const locked = LOCKED_KEYWORDS[language];
+  if (locked === undefined) return keywordsFromTable(table);
+  // A locked byte that left the official table would silently drift the
+  // dialect — fall through to the table instead of emitting it.
+  const fromTable = keywordsFromTable(table);
+  if (fromTable === null) return null;
+  return TABLE_KEY_PAIRS.every(([tableKey, kwKey]) =>
+    table[tableKey].map((k) => k.trim()).includes(locked[kwKey]),
+  )
+    ? locked
+    : fromTable;
+}
+
+/** Official keywords, falling back to the en table for table-less languages. */
+export function officialKeywordsOrEn(language: string): GherkinKeywords {
+  return officialKeywords(language) ?? officialKeywords('en') ?? LOCKED_KEYWORDS['en']!;
+}
+
+/**
+ * Official step keyword → kind across every dialect (star-filtered,
+ * trimmed). And/But/`*` are absent by construction — callers decide their
+ * inheritance. en/zh-CN resolve to the same kinds as the former hand-rolled
+ * regexes; other official dialects (fr Soit/Quand/Alors, …) now classify
+ * correctly instead of falling into a default.
+ */
+export const STEP_KIND_BY_KEYWORD: ReadonlyMap<string, 'given' | 'when' | 'then'> = (() => {
+  const map = new Map<string, 'given' | 'when' | 'then'>();
+  for (const table of Object.values(dialects)) {
+    for (const kind of ['given', 'when', 'then'] as const) {
+      for (const raw of table[kind]) {
+        const k = raw.trim();
+        if (k !== '' && k !== '*' && !map.has(k)) map.set(k, kind);
+      }
+    }
+  }
+  return map;
+})();
+
+export function stepKeywordToOfficialKind(keyword: string): 'given' | 'when' | 'then' | null {
+  return STEP_KIND_BY_KEYWORD.get(keyword.trim()) ?? null;
+}
+
+function escapeRegExp(k: string): string {
+  return k.replaceAll(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+
+/**
+ * Top-level block keywords across every official dialect (2-space indent +
+ * keyword + `:`) — next-block boundary scanning must recognize a block end
+ * in any language, not just the four hardcoded ones.
+ */
+export const BLOCK_KEYWORD_LINE_RE: RegExp = new RegExp(
+  `^  (?:${[
+    ...new Set(
+      Object.values(dialects)
+        .flatMap((table) => [
+          ...table.feature,
+          ...table.rule,
+          ...table.scenario,
+          ...table.scenarioOutline,
+          ...table.background,
+        ])
+        .map((k) => k.trim())
+        .filter((k) => k !== '' && k !== '*'),
+    ),
+  ]
+    .map(escapeRegExp)
+    .join('|')}):`,
+  'u',
+);

package/src/spec/migrateNative.ts

@@ -0,0 +1,201 @@
+/**
+ * Legacy → native spec migration (v1 tag-based flat layout → native `规则:`
+ * blocks with nested `场景:`). Pure text transform with IO injected by the
+ * caller. Used by `spec migrate-native` (interactive + --dry-run) and the
+ * in-repo one-shot migration.
+ *
+ * Parsing ALWAYS goes through the official @cucumber/gherkin parser
+ * (parseFeatureSource) — no hand-rolled line scanning; the legacy ROLE is
+ * derived from the tag set the official parser exposes per scenario.
+ */
+
+import { officialKeywordsOrEn } from './keywords.ts';
+import { parseFeatureSource, sourceDialect } from './parser.ts';
+
+export interface MigrateBlock {
+  reqIds: string[];
+  isRule: boolean;
+  skip: boolean;
+  title: string;
+  /** Statement description lines for rules; step [keyword,text] pairs for acceptances. */
+  descriptionLines: string[];
+  steps: { keyword: string; text: string }[];
+}
+
+export interface MigrateAnalysis {
+  /** Gherkin dialect the source resolved to (en start, zh-CN fallback). */
+  language: string;
+  blocks: MigrateBlock[];
+}
+
+export type MigrateResult =
+  | { ok: true; content: string; rules: number; scenarios: number }
+  | { ok: false; message: string };
+
+const REQ_TAG_RE = /^@?req:(r\d+)$/u;
+
+function tagsOf(tags: readonly { name: string }[]): {
+  reqIds: string[];
+  isRule: boolean;
+  skip: boolean;
+} {
+  const names = tags.map((t) => t.name);
+  const reqIds = names
+    .map((n) => n.match(REQ_TAG_RE)?.[1])
+    .filter((v): v is string => v !== undefined);
+  const isRule = names.some((n) => n === '@rule' || n === '@human');
+  const skip = names.some((n) => n === '@skip' || n === '@experimental');
+  return { reqIds, isRule, skip };
+}
+
+/**
+ * True when the source already uses the native layout (has at least one
+ * top-level `规则:` block). Uses the official parser.
+ */
+export function hasNativeRules(source: string): boolean {
+  try {
+    const { doc } = parseFeatureSource(source);
+    return (doc.feature?.children ?? []).some((c) => c.rule !== undefined);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Analyze a legacy source through the official parser: every top-level
+ * scenario becomes a block; its role comes from the tags, its body from the
+ * official description/step fields.
+ */
+export function analyzeLegacy(source: string): MigrateAnalysis | { ok: false; message: string } {
+  const { doc } = parseFeatureSource(source);
+  const blocks: MigrateBlock[] = [];
+  for (const child of doc.feature?.children ?? []) {
+    if (child.rule) {
+      // native source — nothing to migrate here; caller should skip
+      continue;
+    }
+    const sc = child.scenario;
+    if (!sc) continue;
+    const { reqIds, isRule, skip } = tagsOf(sc.tags);
+    blocks.push({
+      reqIds,
+      isRule,
+      skip,
+      title: sc.name,
+      descriptionLines: (sc.description ?? '')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l !== ''),
+      steps: sc.steps.map((s) => ({ keyword: s.keyword.trim(), text: s.text.trim() })),
+    });
+  }
+  return { language: sourceDialect(source), blocks };
+}
+
+/** Strip `- ` list markers from a rule-statement line (legacy prose residue). */
+function stripBullet(line: string): string {
+  return line.replace(/^-\s+/u, '');
+}
+
+/**
+ * Migrate one legacy feature source to the native layout. Structural rules:
+ * rules keep file order; acceptances nest under the rule carrying their
+ * @req id (file order); acceptances without a matching rule stay top-level
+ * orphans. Non-scenario lines (headers/feature/comments) are NOT touched —
+ * the native output only emits tag/rule/scenario lines, so the preamble is
+ * reconstructed by the caller from the original file.
+ */
+export function migrateNativeSource(source: string): MigrateResult {
+  const analysis = analyzeLegacy(source);
+  if ('ok' in analysis) return { ok: false, message: analysis.message };
+
+  const { language, blocks } = analysis as MigrateAnalysis;
+  if (blocks.length === 0) {
+    return { ok: false, message: 'no legacy scenarios found (already native?)' };
+  }
+
+  // Keywords come from the official gherkin dialect table so the output
+  // stays parseable in one language — the preamble (`# language:` header,
+  // `Feature:`/`功能:` line) is kept verbatim and already matches it. The
+  // trailing parse self-check guards the rest.
+  const kw = officialKeywordsOrEn(language);
+  // The auto-nested acceptance title is a synthesized name, not a keyword —
+  // no official source exists, so it keeps its localized map.
+  const autoAcceptance = language === 'zh-CN' ? '验收示例' : 'Acceptance example';
+
+  // preamble: everything before the first top-level tag line (headers,
+  // feature line, comments) — cut textually, preserved verbatim.
+  const lines = source.split('\n');
+  let preEnd = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if ((lines[i] ?? '').startsWith('  @')) break;
+    preEnd = i + 1;
+  }
+  const preamble = lines.slice(0, preEnd);
+
+  const out: string[] = [...preamble];
+  let rules = 0;
+  let scenarios = 0;
+  const consumed = new Set<number>();
+
+  for (const b of blocks) {
+    if (!b.isRule) continue;
+    rules++;
+    out.push(`  @req:${b.reqIds[0] ?? ''}`);
+    out.push(`  ${kw.rule}: ${b.title}`);
+    for (const line of b.descriptionLines) {
+      const text = stripBullet(line);
+      if (text !== '') out.push(`    ${text}`);
+    }
+    // A legacy rule scenario may carry its own acceptance steps inline
+    // (description + steps in one block). They become the rule's first
+    // nested scenario — file-order semantics, never dropped.
+    if (b.steps.length > 0) {
+      out.push('');
+      if (b.skip) out.push('    @skip');
+      out.push(`    ${kw.scenario}: ${autoAcceptance}`);
+      for (const s of b.steps) out.push(`      ${s.keyword} ${s.text}`);
+      scenarios++;
+    }
+    for (const [ai, a] of blocks.entries()) {
+      if (a.isRule || consumed.has(ai)) continue;
+      if (!a.reqIds.some((rid) => b.reqIds.includes(rid))) continue;
+      consumed.add(ai);
+      scenarios++;
+      out.push('');
+      if (a.skip) out.push('    @skip');
+      out.push(`    ${kw.scenario}: ${a.title}`);
+      for (const s of a.steps) out.push(`      ${s.keyword} ${s.text}`);
+    }
+  }
+  // Unbound acceptance scenarios (no matching rule) are emitted last at
+  // top level — native feature-level examples with no requirement handle.
+  // Under official Gherkin parsing they are absorbed into the preceding rule,
+  // which is their natural functional home; no special signal exists for them.
+  for (const [ai, a] of blocks.entries()) {
+    if (a.isRule || consumed.has(ai)) continue;
+    consumed.add(ai);
+    scenarios++;
+    out.push('');
+    if (a.skip) out.push('  @skip');
+    out.push(`  ${kw.scenario}: ${a.title}`);
+    for (const s of a.steps) out.push(`    ${s.keyword} ${s.text}`);
+  }
+
+  if (rules === 0) {
+    return { ok: false, message: 'no legacy rule scenarios found (@req + @rule/@human)' };
+  }
+
+  const content = `${out.join('\n')}\n`;
+  // Fail closed: never hand back content the official parser rejects — a
+  // dialect mismatch would otherwise land on disk as silent corruption.
+  try {
+    parseFeatureSource(content);
+  } catch (error) {
+    return {
+      ok: false,
+      message: `migrated output failed parse self-check: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+  return { ok: true, content, rules, scenarios };
+}

package/src/spec/parser.ts

@@ -1,21 +1,25 @@
 /**
  * Single-track capability .feature parsing (spec-parsing capability).
  *
- * Language fallback chain (r7): start with the `en` matcher — a
- * `# language:` header switches dialect automatically mid-scan; on failure
- * retry with the zh-CN matcher (Chinese keywords without a header); only then
- * surface a parse error. locale zh-Hans maps to gherkin zh-CN.
+ * Native v2 model: `功能:` → `规则:` blocks (requirement: title + free-form
+ * description + `@req:<id>` handle) → nested `场景:` (executable examples).
+ * Top-level `场景:` outside any rule become orphans. Legacy role tags
+ * (@human/@rule/@executable/@manual) are inert — the parser only reads
+ * `@req` (handle) and `@skip`/`@experimental` (runner opt-out). Files in the
+ * legacy flat layout must be migrated with `spec migrate-native`.
  */
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from '@cucumber/gherkin';
 import type { GherkinDocument } from '@cucumber/messages';
 
 import {
-  MUST_WORD_RE,
   type CapabilityDoc,
   type CapabilityHeader,
+  type RuleIR,
   type ScenarioIR,
+  type ScenarioStepKind,
   type SpecStructuralError,
 } from './ir.ts';
+import { stepKeywordToOfficialKind } from './keywords.ts';
 
 export class SpecParseError extends Error {}
 
@@ -49,16 +53,32 @@ export function parseFeatureSource(source: string): { doc: GherkinDocument; lang
   );
 }
 
+/**
+ * Unified source-dialect policy (r41/r88): an explicit per-file
+ * `# language:` header wins; headerless content is auto-discovered through
+ * the official matcher chain (en start, zh-CN fallback); anything still
+ * undiscoverable falls back to en. Unknown header names are returned
+ * as-is — callers pick vocabulary via officialKeywordsOrEn, and the
+ * migration parse self-check fail-closes genuinely broken headers.
+ */
+export function sourceDialect(source: string): string {
+  const firstLine = source.split('\n').find((l) => l.trim() !== '');
+  const header = firstLine?.match(/^#\s*language:\s*(\S+)\s*$/u)?.[1];
+  if (header !== undefined) return header;
+  try {
+    return parseFeatureSource(source).language;
+  } catch {
+    return 'en';
+  }
+}
+
 const REQ_TAG_RE = /^@?req:(r\d+)$/u;
 
-/** Gherkin keyword (zh-CN + en) → step kind; And/But/* inherit via fallback. */
-function stepKeywordToKind(keyword: string): 'given' | 'when' | 'then' {
-  const kw = keyword.trim();
-  if (/^(假如|Given)/iu.test(kw)) return 'given';
-  if (/^(当|When)/iu.test(kw)) return 'when';
-  if (/^(那么|Then)/iu.test(kw)) return 'then';
-  return 'given';
+/** Gherkin keyword → step kind, from the official dialect tables; And/But/* inherit via fallback. */
+function stepKeywordToKind(keyword: string): ScenarioStepKind {
+  return stepKeywordToOfficialKind(keyword) ?? 'given';
 }
+
 const HEADER_RE = /^#\s*(capability|purpose|scope):\s*(.*)$/u;
 
 function extractHeader(source: string): CapabilityHeader {
@@ -75,37 +95,47 @@ function extractHeader(source: string): CapabilityHeader {
   return header;
 }
 
-function classify(tags: string[]): {
-  classification: ScenarioIR['classification'];
-  errors: SpecStructuralError[];
-} {
-  const errors: SpecStructuralError[] = [];
-  const has = (t: string): boolean => tags.includes(t);
-  const human = has('human');
-  const executable = has('executable');
-  const label = tags.join(',');
-
-  if (has('manual')) {
-    errors.push({
-      code: 'tag:manual-removed',
-      message: `@manual was removed in 0.3.0 — drop the tag (@human already carries the human-judgement semantics) (tags: ${label})`,
-    });
-  }
-  if (human && executable) {
-    errors.push({
-      code: 'tag:mutually-exclusive',
-      message: `@human 与 @executable 互斥(tags: ${label})`,
-    });
-  }
-  const classification: ScenarioIR['classification'] = human
-    ? 'human'
-    : executable
-      ? 'executable'
-      : 'unclassified';
-  return { classification, errors };
+interface RawTags {
+  names: string[]; // without leading '@'
+  reqId: string;
+}
+
+function parseTags(tags: readonly { name: string }[]): RawTags {
+  const names = tags.map((t) => t.name.replace(/^@/u, ''));
+  const req = tags.map((t) => t.name.match(REQ_TAG_RE)?.[1]).find((v): v is string => !!v);
+  return { names, reqId: req ?? '' };
 }
 
-/** Parse one capability .feature source into the single-track IR. */
+function collectScenario(sc: {
+  tags: readonly { name: string }[];
+  name: string;
+  steps: readonly { keyword: string; text: string }[];
+}): ScenarioIR {
+  const { names, reqId: _ignored } = parseTags(sc.tags);
+  const skipTokens = new Set(['skip', 'experimental']);
+  const runnable = !names.some((n) => skipTokens.has(n));
+  const steps = sc.steps.map((s) => ({
+    kind: stepKeywordToKind(s.keyword),
+    text: s.text.trim(),
+  }));
+  return {
+    name: sc.name,
+    tags: names.filter(
+      (n) =>
+        !n.startsWith('req') &&
+        !skipTokens.has(n) &&
+        !n.startsWith('rule') &&
+        !n.startsWith('human') &&
+        !n.startsWith('executable'),
+    ),
+    runnable,
+    stepCount: steps.length,
+    steps,
+    statement: steps.map((s) => s.text).join('\n'),
+  };
+}
+
+/** Parse one capability .feature source into the native single-track IR. */
 export function parseCapability(source: string, fileName = '<inline>'): CapabilityDoc {
   const errors: SpecStructuralError[] = [];
   const header = extractHeader(source);
@@ -118,56 +148,38 @@ export function parseCapability(source: string, fileName = '<inline>'): Capabili
   const { doc, language } = parseFeatureSource(source);
   const feature = doc.feature;
   const featureName = feature?.name ?? '';
-  const scenarios: ScenarioIR[] = [];
+  const rules: RuleIR[] = [];
+  const orphans: ScenarioIR[] = [];
 
   for (const child of feature?.children ?? []) {
     const rule = child.rule;
-    if (rule && rule.children.some((c) => c.scenario)) {
-      errors.push({
-        code: 'rule:nested-scenario',
-        message: `Rule 块内嵌场景被拒绝(rule: ${rule.name})`,
+    if (rule) {
+      const { names, reqId } = parseTags(rule.tags);
+      const description = (rule.description ?? '')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l !== '')
+        .join('\n');
+      const scenarios: ScenarioIR[] = [];
+      for (const rc of rule.children) {
+        if (rc.scenario) scenarios.push(collectScenario(rc.scenario));
+      }
+      rules.push({
+        reqId,
+        title: rule.name,
+        description,
+        scenarios,
+        tags: names.filter(
+          (n) => !n.startsWith('req') && !n.startsWith('rule') && !n.startsWith('human'),
+        ),
       });
       continue;
     }
     const scenario = child.scenario;
-    if (!scenario) continue;
-
-    const tags = scenario.tags.map((t) => t.name.replace(/^@/u, ''));
-    const reqIds = scenario.tags
-      .map((t) => t.name.match(REQ_TAG_RE)?.[1])
-      .filter((v): v is string => v !== undefined);
-
-    const kind = classify(tags);
-    errors.push(...kind.errors);
-
-    const description = (scenario.description ?? '')
-      .split('\n')
-      .map((l) => l.trim())
-      .filter((l) => l !== '');
-    const stepTexts = scenario.steps.map((s) => s.text.trim());
-    const statement = [...description, ...stepTexts].join('\n');
-    const steps = scenario.steps.map((s) => ({
-      kind: stepKeywordToKind(s.keyword),
-      text: s.text.trim(),
-    }));
-
-    if (kind.classification === 'human' && !MUST_WORD_RE.test(statement)) {
-      errors.push({
-        code: 'rule:missing-must-word',
-        message: `@human 规则场景描述必须含 MUST/SHALL(scenario: ${scenario.name})`,
-      });
+    if (scenario) {
+      orphans.push(collectScenario(scenario));
     }
-
-    scenarios.push({
-      name: scenario.name,
-      tags,
-      reqIds,
-      classification: kind.classification,
-      statement,
-      stepCount: stepTexts.length,
-      steps,
-    });
   }
 
-  return { fileName, header, featureName, language, scenarios, errors };
+  return { fileName, header, featureName, language, rules, orphans, errors };
 }