@sun-asterisk/sungen 2.3.1 → 2.4.1

package/src/generators/test-generator/patterns/table-patterns.ts

@@ -1,19 +1,49 @@
 /**
  * Table Patterns
  * Handles: table row assertions, table cell lookups, actions in table rows
+ *
+ * Syntax (v2.4 final):
+ * - User see [Col] column in [Table] table                             # column exists
+ * - User see [Ref] row in [Table] table with {{value}}                 # row exists (enters row scope)
+ * - User see [Ref] row in [Table] table with {{value}} is hidden       # row hidden
+ * - User see [Table] table with {{count}}                              # row count
+ * - User see [Table] table is empty                                    # empty table
+ * - User see [Col] column with {{value}}                               # cell value (row scoped — handled in step-mapper)
+ * - User click [Act] button in [Table] table with {{filter}}           # action in row
+ * - User see [Table] table match data:                                 # exact table match with inline DataTable
+ *       | Header1    | Header2    |
+ *       | {{value1}} | {{value2}} |
  */
 
-import { StepPattern } from './types';
+import { StepPattern, PatternContext } from './types';
+
+/** Helper: check if current step is in a Given context */
+function isGivenContext(context: PatternContext): boolean {
+  return context.effectiveKeyword === 'Given';
+}
+
+/** Map Gherkin element type to Playwright ARIA role */
+const typeToRole: Record<string, string> = {
+  button: 'button',
+  link: 'link',
+  checkbox: 'checkbox',
+  icon: 'img',
+  image: 'img',
+  radio: 'radio',
+  switch: 'switch',
+};
 
 export const tablePatterns: StepPattern[] = [
-  // "User see [Users] table with {{count}} rows" (preferred)
-  // Also accepts: "User see [Users] table has {{count}} rows" (backward compat)
+  // "User see [Table] table with {{count}}" — row count (no "rows" keyword needed)
   {
     name: 'table-row-count',
     matcher: (step) => {
-      return /\btable\s+(?:has|with)\b/i.test(step.text) &&
-             /\}\}\s*rows?\b/i.test(step.text) &&
-             !!step.dataRef;
+      return step.elementType === 'table' &&
+             /\btable\s+with\b/i.test(step.text) &&
+             !!step.dataRef &&
+             !/\brow\b/i.test(step.text) &&
+             !/\bcolumn\b/i.test(step.text) &&
+             !/\bempty\b/i.test(step.text);
     },
     resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(
@@ -21,44 +51,47 @@ export const tablePatterns: StepPattern[] = [
       );
       const count = context.dataResolver.resolveData(step.dataRef!, context.featureName);
 
+      const isGiven = isGivenContext(context);
       return {
         templateName: 'table-row-count',
-        data: { ...resolved, expectedCount: count },
-        comment: `Assert ${step.selectorRef} table has ${count} rows`,
+        data: { ...resolved, expectedCount: count, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table has ${count} rows`,
       };
     },
     priority: 16,
   },
 
-  // "User see [Users] table has [Email] column" (backward compat)
-  // Preferred: "User see [Email] column in [Users] table" (parent scoping)
+  // "User see [Col] column in [Table] table"
   {
     name: 'table-column-exists',
     matcher: (step) => {
-      return /\btable\s+has\b/i.test(step.text) &&
-             /\bcolumn\b/i.test(step.text);
+      return /\bcolumn\s+in\b/i.test(step.text) &&
+             /\btable\b/i.test(step.text) &&
+             !step.dataRef;
     },
     resolver: (step, context) => {
-      // Extract column name from second [bracket] reference
+      // brackets[0] = Col, brackets[1] = Table
       const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const columnName = brackets.length >= 2
+      const columnName = brackets[0]?.replace(/[\[\]]/g, '') || 'Unknown';
+      const tableName = brackets.length >= 2
         ? brackets[1].replace(/[\[\]]/g, '')
-        : 'Unknown';
+        : brackets[0]?.replace(/[\[\]]/g, '') || '';
 
       const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, 'table', step.nth
+        tableName, context.featureName, 'table', step.nth
       );
 
+      const isGiven = isGivenContext(context);
       return {
         templateName: 'table-column-exists',
-        data: { ...resolved, columnName },
-        comment: `Assert ${step.selectorRef} table has ${columnName} column`,
+        data: { ...resolved, columnName, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${columnName} column in ${tableName} table`,
       };
     },
     priority: 16,
   },
 
-  // "User see [Users] table is empty"
+  // "User see [Table] table is empty"
   {
     name: 'table-is-empty',
     matcher: (step) => {
@@ -69,167 +102,178 @@ export const tablePatterns: StepPattern[] = [
         step.selectorRef!, context.featureName, 'table', step.nth
       );
 
+      const isGiven = isGivenContext(context);
       return {
         templateName: 'table-empty',
-        data: { ...resolved },
-        comment: `Assert ${step.selectorRef} table is empty`,
+        data: { ...resolved, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table is empty`,
       };
     },
     priority: 16,
   },
 
-  // "User see [Users] table row with {{name}} has [Status] with {{value}}"
+  // "User see [Ref] row in [Table] table with {{value}}" — row exists (enters row scope)
   {
-    name: 'table-cell-by-filter',
+    name: 'table-row-exists',
     matcher: (step) => {
-      return /\btable\s+row\s+with\b/i.test(step.text) &&
-             /\bhas\b/i.test(step.text);
+      return step.elementType === 'row' &&
+             /\bin\b.*\btable\b/i.test(step.text) &&
+             /\bwith\b/i.test(step.text) &&
+             !!step.dataRef &&
+             !/\bis\s+hidden\b/i.test(step.text);
     },
     resolver: (step, context) => {
-      // Extract: [Table] table row with {{filter}} has [Col] with {{value}}
+      // brackets[0] = Ref (row label), brackets[1] = Table
       const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const tableName = brackets[0]?.replace(/[\[\]]/g, '') || '';
-      const columnName = brackets.length >= 2
+      const rowLabel = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const tableName = brackets.length >= 2
         ? brackets[1].replace(/[\[\]]/g, '')
         : '';
 
-      // Extract data refs: first is filter, second is cell value
-      const dataRefs = step.text.match(/\{\{([^}]+)\}\}/g) || [];
-      const filterRef = dataRefs[0]?.replace(/\{\{|\}\}/g, '') || '';
-      const valueRef = dataRefs.length >= 2
-        ? dataRefs[1].replace(/\{\{|\}\}/g, '')
-        : '';
-
-      const filterValue = filterRef
-        ? context.dataResolver.resolveData(filterRef, context.featureName)
-        : '';
-      const cellValue = valueRef
-        ? context.dataResolver.resolveData(valueRef, context.featureName)
-        : '';
-
       const resolved = context.selectorResolver.resolveSelector(
         tableName, context.featureName, 'table', step.nth
       );
+      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
 
+      const isGiven = isGivenContext(context);
       return {
-        templateName: 'table-cell-by-filter',
-        data: { ...resolved, filterValue, columnName, cellValue },
-        comment: `Assert ${tableName} table row with ${filterRef} has ${columnName} = ${valueRef}`,
+        templateName: 'table-row-exists',
+        data: { ...resolved, filterValue, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table with ${step.dataRef}`,
       };
     },
     priority: 17,
   },
 
-  // "User see [Users] table row 1 [Name] cell with {{value}}"
+  // "User see [Ref] row in [Table] table with {{value}} is hidden"
   {
-    name: 'table-cell-by-index',
+    name: 'table-row-hidden',
     matcher: (step) => {
-      return /\btable\s+row\s+\d+\b/i.test(step.text) &&
-             /\bcell\b/i.test(step.text);
+      return step.elementType === 'row' &&
+             /\bin\b.*\btable\b/i.test(step.text) &&
+             /\bwith\b/i.test(step.text) &&
+             !!step.dataRef &&
+             /\bis\s+hidden\b/i.test(step.text);
     },
     resolver: (step, context) => {
+      // brackets[0] = Ref (row label), brackets[1] = Table
       const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const tableName = brackets[0]?.replace(/[\[\]]/g, '') || '';
-      const columnName = brackets.length >= 2
+      const rowLabel = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const tableName = brackets.length >= 2
         ? brackets[1].replace(/[\[\]]/g, '')
         : '';
 
-      const rowMatch = step.text.match(/\brow\s+(\d+)\b/i);
-      const rowIndex = rowMatch ? parseInt(rowMatch[1], 10) : 1;
-
-      const cellValue = step.dataRef
-        ? context.dataResolver.resolveData(step.dataRef, context.featureName)
-        : '';
-
       const resolved = context.selectorResolver.resolveSelector(
         tableName, context.featureName, 'table', step.nth
       );
-
-      return {
-        templateName: 'table-cell-by-index',
-        data: { ...resolved, rowIndex, columnName, cellValue },
-        comment: `Assert ${tableName} table row ${rowIndex} ${columnName} cell = ${step.dataRef}`,
-      };
-    },
-    priority: 17,
-  },
-
-  // "User see [Users] table row with {{name}}" (preferred)
-  // Also accepts: "User see [Users] table has row with {{name}}" (backward compat)
-  {
-    name: 'table-row-exists',
-    matcher: (step) => {
-      return /\btable\s+(?:has\s+)?row\s+with\b/i.test(step.text) && !!step.dataRef;
-    },
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, 'table', step.nth
-      );
-      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
-
-      return {
-        templateName: 'table-row-exists',
-        data: { ...resolved, filterValue },
-        comment: `Assert ${step.selectorRef} table has row with ${step.dataRef}`,
-      };
-    },
-    priority: 18,
-  },
-
-  // "User see [Users] table has no row with {{name}}"
-  {
-    name: 'table-row-not-exists',
-    matcher: (step) => {
-      return /\btable\s+has\s+no\s+row\s+with\b/i.test(step.text) && !!step.dataRef;
-    },
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, 'table', step.nth
-      );
       const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
 
+      const isGiven = isGivenContext(context);
       return {
         templateName: 'table-row-not-exists',
-        data: { ...resolved, filterValue },
-        comment: `Assert ${step.selectorRef} table has no row with ${step.dataRef}`,
+        data: { ...resolved, filterValue, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table is hidden`,
       };
     },
     priority: 19,
   },
 
-  // "User click [Edit] in [Users] table row with {{name}}"
+  // "User click [Act] button in [Table] table with {{filter}}" — action in row
   {
     name: 'table-action-in-row',
     matcher: (step) => {
-      return /\bin\b.*\btable\s+row\s+with\b/i.test(step.text);
+      return /\bin\b.*\btable\b/i.test(step.text) &&
+             /\bwith\b/i.test(step.text) &&
+             !!step.dataRef &&
+             step.elementType !== 'column' &&
+             step.elementType !== 'row' &&
+             step.elementType !== 'table';
     },
     resolver: (step, context) => {
+      // brackets[0] = Act (element name), brackets[1] = Table
       const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
       const elementName = brackets[0]?.replace(/[\[\]]/g, '') || '';
       const tableName = brackets.length >= 2
         ? brackets[1].replace(/[\[\]]/g, '')
         : '';
 
-      const dataRefs = step.text.match(/\{\{([^}]+)\}\}/g) || [];
-      const filterRef = dataRefs[0]?.replace(/\{\{|\}\}/g, '') || '';
-      const filterValue = filterRef
-        ? context.dataResolver.resolveData(filterRef, context.featureName)
+      const filterValue = step.dataRef
+        ? context.dataResolver.resolveData(step.dataRef, context.featureName)
         : '';
 
       const tableResolved = context.selectorResolver.resolveSelector(
         tableName, context.featureName, 'table', 0
       );
 
-      // Determine action
+      // Determine action from step text
       const actionMatch = step.text.match(/\b(click|check|uncheck)\b/i);
       const action = actionMatch ? actionMatch[1].toLowerCase() : 'click';
 
+      // Extract element type (word after [Act]) and map to ARIA role
+      const elementTypeMatch = step.text.match(/\]\s+([\w-]+)\s+in\b/i);
+      const elementType = elementTypeMatch ? elementTypeMatch[1].toLowerCase() : 'button';
+      const elementRole = typeToRole[elementType] || elementType;
+
       return {
         templateName: 'table-action-in-row',
-        data: { ...tableResolved, elementName, filterValue, action },
-        comment: `${action} ${elementName} in ${tableName} table row with ${filterRef}`,
+        data: { ...tableResolved, elementName, filterValue, action, elementRole },
+        comment: `${action} ${elementName} in ${tableName} table row with ${step.dataRef}`,
       };
     },
     priority: 17,
   },
+
+  // "User see [Table] table match data:" — filter-based table match with inline DataTable
+  // First row = headers, remaining rows = expected data
+  // Uses filter({ hasText }) per row — resilient to data changes, row ordering, extra rows
+  {
+    name: 'table-match-data',
+    matcher: (step) => {
+      return step.elementType === 'table' &&
+             /\btable\s+match\s+data\b/i.test(step.text) &&
+             !!step.dataTable;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+
+      const dataTable = step.dataTable!;
+
+      // Resolve {{variable}} references in cell values
+      const resolvedRows = dataTable.rows.map(row => ({
+        cells: row.cells.map(cell => {
+          const varMatch = cell.match(/^\{\{([a-z0-9\-\.\_]+)\}\}$/i);
+          if (varMatch) {
+            return context.dataResolver.resolveData(varMatch[1], context.featureName);
+          }
+          return cell;
+        }),
+      }));
+
+      // Pre-compute filter-based assertion lines
+      // For each expected row: chain .filter({ hasText }) for all cell values, then assert visible
+      const assertions: string[] = [];
+      for (const row of resolvedRows) {
+        const filters = row.cells
+          .map(cell => `.filter({ hasText: '${cell.replace(/'/g, "\\'")}' })`)
+          .join('');
+        assertions.push(
+          `await expect(rows${filters}).toBeVisible();`
+        );
+      }
+
+      const isGiven = isGivenContext(context);
+      return {
+        templateName: 'table-match-data',
+        data: {
+          ...resolved,
+          assertions,
+          isGiven,
+        },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table contains ${resolvedRows.length} expected row(s)`,
+      };
+    },
+    priority: 20, // Higher than other table patterns to match first
+  },
 ];

package/src/generators/test-generator/patterns/types.ts

@@ -42,6 +42,8 @@ export interface PatternContext {
   screenName?: string;
   featurePath?: string;
   scenarioSteps?: ParsedStep[];
+  /** Effective Gherkin keyword (Given/When/Then), resolved from And/But */
+  effectiveKeyword?: string;
 }
 
 /**

package/src/generators/test-generator/step-mapper.ts

@@ -29,6 +29,11 @@ export class StepMapper {
   private currentScenarioSteps?: ParsedStep[];
   private inDialogScope: boolean = false;
   private inFrameScope: boolean = false;
+  /** Tracks the last primary keyword (Given/When/Then) for resolving And/But */
+  private lastPrimaryKeyword: string = 'Given';
+  /** Row scope: when active, column assertions are scoped to this row */
+  private inRowScope: boolean = false;
+  private rowScopeTable: string = '';
 
   constructor(options: { verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string } = {}) {
     this.verbose = options.verbose ?? false;
@@ -74,6 +79,9 @@ export class StepMapper {
     // Reset dialog and frame scope at the start of each new scenario
     this.inDialogScope = false;
     this.inFrameScope = false;
+    this.inRowScope = false;
+    this.rowScopeTable = '';
+    this.lastPrimaryKeyword = 'Given';
     this.templateEngine.resetBaseContext();
   }
 
@@ -84,6 +92,12 @@ export class StepMapper {
   mapStep(step: ParsedStep): MappedStep | Promise<MappedStep> {
     this.stepCounter++;
 
+    // Track effective keyword: And/But inherit from previous Given/When/Then
+    const keyword = step.keyword.trim();
+    if (keyword === 'Given' || keyword === 'When' || keyword === 'Then') {
+      this.lastPrimaryKeyword = keyword;
+    }
+
     // Frame scope directives — intercept before pattern matching
     if (/\bswitch(?:es)?\s+to\b/i.test(step.text) &&
         (step.elementType === 'frame' || step.elementType === 'iframe')) {
@@ -154,11 +168,29 @@ export class StepMapper {
       return { code: '', comment: `Enter dialog scope${step.selectorRef ? ': ' + step.selectorRef : ''}` };
     }
 
+    // Row-scoped column assertion: "User see [Col] column with {{value}}"
+    // Must be checked BEFORE pattern matching (like dialog/frame scope)
+    if (this.inRowScope && step.elementType === 'column' &&
+        !!step.dataRef && /\bwith\b/i.test(step.text) &&
+        !/\btable\b/i.test(step.text)) {
+      return this.generateRowScopedColumnAssertion(step);
+    }
+
     // Try pattern registry first
     const context = this.createPatternContext();
     const mappedStep = this.patternRegistry.generateStep(step, context);
-    
+
     if (mappedStep) {
+      // Enter row scope when a row-in-table step is matched
+      if (step.elementType === 'row' && /\bin\b.*\btable\b/i.test(step.text) &&
+          /\bwith\b/i.test(step.text) && !/\bis\s+hidden\b/i.test(step.text)) {
+        const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+        this.inRowScope = true;
+        this.rowScopeTable = brackets.length >= 2
+          ? brackets[1].replace(/[\[\]]/g, '')
+          : '';
+      }
+
       if (this.verbose) {
         console.log(`  ✓ Pattern matched: ${step.text.substring(0, 50)}...`);
       }
@@ -172,6 +204,59 @@ export class StepMapper {
     };
   }
 
+  /**
+   * Generate column assertion scoped to the current row.
+   * Uses columns config for exact cell targeting (nth), or filter fallback.
+   *
+   * With columns:  await expect(tableRow.getByRole('cell').nth(index)).toHaveText('value');
+   * Without:       await expect(tableRow.getByRole('cell').filter({ hasText: 'value' })).toBeVisible();
+   */
+  private generateRowScopedColumnAssertion(step: ParsedStep): MappedStep {
+    const columnRef = step.selectorRef || '';
+    const cellValue = step.dataRef
+      ? this.dataResolver.resolveData(step.dataRef, this.featureName)
+      : '';
+
+    // Try to find column index from table's columns config
+    let columnIndex: number | undefined;
+    if (this.rowScopeTable) {
+      try {
+        const tableResolved = this.selectorResolver.resolveSelector(
+          this.rowScopeTable, this.featureName, 'table', 0
+        );
+        const columnKey = columnRef.toLowerCase().normalize('NFC');
+        columnIndex = tableResolved.columns?.[columnKey]?.index;
+      } catch {
+        // Table not found — fallback to filter
+      }
+    }
+
+    const isGiven = this.lastPrimaryKeyword === 'Given';
+    const escapedValue = cellValue.replace(/'/g, "\\'");
+
+    let code: string;
+    if (columnIndex !== undefined) {
+      // Exact cell: nth(index) + toHaveText
+      if (isGiven) {
+        code = `await expect(tableRow.getByRole('cell').nth(${columnIndex})).toHaveText('${escapedValue}');`;
+      } else {
+        code = `await expect(tableRow.getByRole('cell').nth(${columnIndex})).toHaveText('${escapedValue}');`;
+      }
+    } else {
+      // Fallback: filter by text
+      if (isGiven) {
+        code = `await tableRow.getByRole('cell').filter({ hasText: '${escapedValue}' }).waitFor();`;
+      } else {
+        code = `await expect(tableRow.getByRole('cell').filter({ hasText: '${escapedValue}' })).toBeVisible();`;
+      }
+    }
+
+    return {
+      code,
+      comment: `${isGiven ? 'Wait' : 'Assert'} ${columnRef} column = ${step.dataRef}`,
+    };
+  }
+
   /**
    * Create pattern context for generators
    */
@@ -191,6 +276,7 @@ export class StepMapper {
       screenName: this.screenName,
       featurePath: this.featurePath,  // Pass feature path to patterns
       scenarioSteps: this.currentScenarioSteps || [],  // Pass scenario steps for path variables
+      effectiveKeyword: this.lastPrimaryKeyword,
     };
   }
 

package/src/orchestrator/ai-rules-updater.ts

@@ -16,13 +16,13 @@ export const AI_RULES_FILE_MAPPING: [string, string][] = [
 
   // Commands — Claude Code
   ['claude-cmd-add-screen.md', '.claude/commands/sungen/add-screen.md'],
-  ['claude-cmd-make-tc.md', '.claude/commands/sungen/make-tc.md'],
-  ['claude-cmd-make-test.md', '.claude/commands/sungen/make-test.md'],
+  ['claude-cmd-create-test.md', '.claude/commands/sungen/create-test.md'],
+  ['claude-cmd-run-test.md', '.claude/commands/sungen/run-test.md'],
 
   // Commands — GitHub Copilot
   ['copilot-cmd-add-screen.md', '.github/prompts/sungen-add-screen.prompt.md'],
-  ['copilot-cmd-make-tc.md', '.github/prompts/sungen-make-tc.prompt.md'],
-  ['copilot-cmd-make-test.md', '.github/prompts/sungen-make-test.prompt.md'],
+  ['copilot-cmd-create-test.md', '.github/prompts/sungen-create-test.prompt.md'],
+  ['copilot-cmd-run-test.md', '.github/prompts/sungen-run-test.prompt.md'],
 
   // Skills — Claude Code
   ['claude-skill-gherkin-syntax.md', '.claude/skills/sungen-gherkin-syntax/SKILL.md'],
@@ -30,7 +30,8 @@ export const AI_RULES_FILE_MAPPING: [string, string][] = [
   ['claude-skill-error-mapping.md', '.claude/skills/sungen-error-mapping/SKILL.md'],
   ['claude-skill-tc-generation.md', '.claude/skills/sungen-tc-generation/SKILL.md'],
   ['claude-skill-selector-fix.md', '.claude/skills/sungen-selector-fix/SKILL.md'],
-  ['claude-skill-gherkin-review.md', '.claude/skills/sungen-gherkin-review/SKILL.md'],
+  ['claude-skill-tc-review.md', '.claude/skills/sungen-tc-review/SKILL.md'],
+  ['claude-skill-viewpoint.md', '.claude/skills/sungen-viewpoint/SKILL.md'],
 
   // Skills — GitHub Copilot
   ['github-skill-sungen-gherkin-syntax.md', '.github/skills/sungen-gherkin-syntax/SKILL.md'],
@@ -38,7 +39,8 @@ export const AI_RULES_FILE_MAPPING: [string, string][] = [
   ['github-skill-sungen-error-mapping.md', '.github/skills/sungen-error-mapping/SKILL.md'],
   ['github-skill-sungen-tc-generation.md', '.github/skills/sungen-tc-generation/SKILL.md'],
   ['github-skill-sungen-selector-fix.md', '.github/skills/sungen-selector-fix/SKILL.md'],
-  ['github-skill-sungen-gherkin-review.md', '.github/skills/sungen-gherkin-review/SKILL.md'],
+  ['github-skill-sungen-tc-review.md', '.github/skills/sungen-tc-review/SKILL.md'],
+  ['github-skill-sungen-viewpoint.md', '.github/skills/sungen-viewpoint/SKILL.md'],
 ];
 
 export class AIRulesUpdater {

package/src/orchestrator/project-initializer.ts

@@ -6,7 +6,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
-import { AI_RULES_FILE_MAPPING } from './ai-rules-updater';
 
 export class ProjectInitializer {
   private baseCwd: string;
@@ -251,7 +250,44 @@ export class ProjectInitializer {
   private createAIRules(): void {
     const aiTemplateDir = path.join(__dirname, 'templates', 'ai-instructions');
 
-    for (const [templateFile, outputRelPath] of AI_RULES_FILE_MAPPING) {
+    // File mapping: [templateFile, outputPath]
+    const fileMapping: [string, string][] = [
+      // Config
+      ['claude-config.md', 'CLAUDE.md'],
+      ['copilot-config.md', '.github/copilot-instructions.md'],
+
+      // Commands — Claude Code
+      ['claude-cmd-add-screen.md', '.claude/commands/sungen/add-screen.md'],
+      ['claude-cmd-create-test.md', '.claude/commands/sungen/create-test.md'],
+      ['claude-cmd-run-test.md', '.claude/commands/sungen/run-test.md'],
+      ['claude-cmd-review.md', '.claude/commands/sungen/review.md'],
+
+      // Commands — GitHub Copilot
+      ['copilot-cmd-add-screen.md', '.github/prompts/sungen-add-screen.prompt.md'],
+      ['copilot-cmd-create-test.md', '.github/prompts/sungen-create-test.prompt.md'],
+      ['copilot-cmd-run-test.md', '.github/prompts/sungen-run-test.prompt.md'],
+      ['copilot-cmd-review.md', '.github/prompts/sungen-review.prompt.md'],
+
+      // Skills — Claude Code
+      ['claude-skill-gherkin-syntax.md', '.claude/skills/sungen-gherkin-syntax/SKILL.md'],
+      ['claude-skill-selector-keys.md', '.claude/skills/sungen-selector-keys/SKILL.md'],
+      ['claude-skill-error-mapping.md', '.claude/skills/sungen-error-mapping/SKILL.md'],
+      ['claude-skill-tc-generation.md', '.claude/skills/sungen-tc-generation/SKILL.md'],
+      ['claude-skill-selector-fix.md', '.claude/skills/sungen-selector-fix/SKILL.md'],
+      ['claude-skill-tc-review.md', '.claude/skills/sungen-tc-review/SKILL.md'],
+      ['claude-skill-viewpoint.md', '.claude/skills/sungen-viewpoint/SKILL.md'],
+
+      // Skills — GitHub Copilot (separate copies with Copilot-friendly descriptions)
+      ['github-skill-sungen-gherkin-syntax.md', '.github/skills/sungen-gherkin-syntax/SKILL.md'],
+      ['github-skill-sungen-selector-keys.md', '.github/skills/sungen-selector-keys/SKILL.md'],
+      ['github-skill-sungen-error-mapping.md', '.github/skills/sungen-error-mapping/SKILL.md'],
+      ['github-skill-sungen-tc-generation.md', '.github/skills/sungen-tc-generation/SKILL.md'],
+      ['github-skill-sungen-selector-fix.md', '.github/skills/sungen-selector-fix/SKILL.md'],
+      ['github-skill-sungen-tc-review.md', '.github/skills/sungen-tc-review/SKILL.md'],
+      ['github-skill-sungen-viewpoint.md', '.github/skills/sungen-viewpoint/SKILL.md'],
+    ];
+
+    for (const [templateFile, outputRelPath] of fileMapping) {
       const outputPath = path.join(this.cwd, outputRelPath);
 
       if (fs.existsSync(outputPath)) {

package/src/orchestrator/screen-manager.ts

@@ -134,7 +134,7 @@ export class ScreenManager {
     console.log('Next steps:');
     console.log(`  1. Fill requirements/spec.md with screen spec (fields, validation, business rules)`);
     console.log(`     Optionally add UI designs to requirements/ui/ (screenshots, mockups)`);
-    console.log(`  2. Generate test cases: /sungen:make-tc ${screenName} (or /sungen-make-tc)`);
+    console.log(`  2. Generate test cases: /sungen:create-test ${screenName} (or /sungen-create-test)`);
     console.log(`  3. Compile: sungen generate --screen ${screenName}`);
     console.log(`  4. Run: npx playwright test\n`);
   }

package/src/orchestrator/templates/ai-instructions/claude-cmd-add-screen.md

@@ -1,6 +1,6 @@
 ---
 name: add-screen
-description: 'Add a new Sungen screen — scaffolds directories and delegates to make-tc for test case creation'
+description: 'Add a new Sungen screen — scaffolds directories and delegates to create-test for test case creation'
 argument-hint: [screen-name] [url-path]
 allowed-tools: Read, Grep, Bash, Glob, AskUserQuestion
 ---
@@ -37,10 +37,10 @@ Ask the user: "Would you like to fill in `requirements/spec.md` now? This helps
 
 Ask the user: "Would you like to create test cases now?"
 
-If yes → **you MUST use the Skill tool** to invoke `/sungen:make-tc <screen>`. This is critical because `make-tc` auto-loads the `sungen-gherkin-syntax` and `sungen-tc-generation` skills which contain the full Gherkin syntax rules, pattern shapes, viewpoint checklists, and output format. **Do NOT attempt to generate test cases yourself** — always invoke the Skill tool so these skills are properly loaded.
+If yes → **you MUST use the Skill tool** to invoke `/sungen:create-test <screen>`. This is critical because `create-test` auto-loads the `sungen-gherkin-syntax` and `sungen-tc-generation` skills which contain the full Gherkin syntax rules, pattern shapes, viewpoint checklists, and output format. **Do NOT attempt to generate test cases yourself** — always invoke the Skill tool so these skills are properly loaded.
 
 ```
-Skill: make-tc
+Skill: create-test
 Args: <screen>
 ```
 
@@ -48,5 +48,5 @@ Args: <screen>
 
 If the user declined test case creation, tell them next steps:
 - Fill `requirements/spec.md` with screen specs (if not done)
-- Run `/sungen:make-tc <screen>` to create test cases
-- Run `/sungen:make-test <screen>` to generate selectors, compile, and run tests
+- Run `/sungen:create-test <screen>` to create test cases
+- Run `/sungen:run-test <screen>` to generate selectors, compile, and run tests