@sun-asterisk/sungen 3.2.34-beta.1 → 3.3.0-alpha.1

package/src/orchestrator/claude-hooks-install.ts

@@ -0,0 +1,168 @@
+/**
+ * Install sungen's Claude Code hooks into `.claude/settings.json` — by MERGING (P0.1, takumi T1).
+ *
+ * A team commits that file, so it holds the user's own hooks, permissions and env. The installer
+ * owns exactly one thing in it: hook entries that run the sungen launcher
+ * (`.claude/hooks/sungen-hook.cjs`, matched exactly — a user's `my-sungen-hook.cjs` is not ours).
+ * Each run removes every such entry and appends the wanted ones, so a hook turned off in
+ * `qa/sungen.config.yaml`, or dropped by a later version, leaves — and nothing else does. That is
+ * also the rollback path: `sungen update` takes out sungen's entries without touching anyone's.
+ *
+ * The first change backs the file up byte for byte, and that pristine backup is never overwritten;
+ * the file keeps its own indentation; an unreadable file is never rewritten; a run that changes
+ * nothing writes nothing.
+ *
+ * Entries use EXEC FORM — `{ command: 'node', args: ['${CLAUDE_PROJECT_DIR}/…/sungen-hook.cjs', hook] }`
+ * (Claude Code ≥ 2.1.139). No shell is involved and Claude Code substitutes the placeholder itself.
+ * A shell-form `node "$CLAUDE_PROJECT_DIR/…"` runs in PowerShell on Windows without Git Bash, where
+ * that variable is empty, and since 2.1.299 a FAILING shell-form PreToolUse hook there blocks every
+ * tool call. `onFailure` is left unset: its default (continue) is the fail-open one, and versions
+ * before 2.1.295 do not know the field.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { allHooks } from '../hooks/hook-registry';
+import { configDisabledHooks } from '../hooks/hook-toggles';
+import type { SungenHook } from '../hooks/hook-result-contract';
+import { readTextFile } from '../harness/read-text';
+import { writeFileAtomic } from '../harness/write-atomic';
+
+export const LAUNCHER_REL = path.join('.claude', 'hooks', 'sungen-hook.cjs');
+/** The launcher as the hook entry names it: Claude Code substitutes the placeholder, no shell does. */
+export const LAUNCHER_ARG = '${CLAUDE_PROJECT_DIR}/.claude/hooks/sungen-hook.cjs';
+const SETTINGS_REL = path.join('.claude', 'settings.json');
+const BACKUP_SUFFIX = '.sungen-backup';
+const LAUNCHER_SRC = path.join(__dirname, 'templates', 'claude-hooks', 'sungen-hook.cjs');
+/** What marks an entry as sungen's: it runs exactly this launcher (exec form `args[0]` or a shell command). */
+const OWNED = /\.claude\/hooks\/sungen-hook\.cjs(?:["'\s]|$)/;
+
+type Settings = Record<string, unknown> & { hooks?: Record<string, unknown> };
+type Entry = { command?: unknown; args?: unknown };
+const entriesOf = (g: unknown): Entry[] | null =>
+  g && typeof g === 'object' && Array.isArray((g as { hooks?: unknown }).hooks) ? (g as { hooks: Entry[] }).hooks : null;
+const argsOf = (e: Entry): string[] => (Array.isArray(e?.args) ? e.args.filter((a): a is string => typeof a === 'string') : []);
+const isOwned = (e: Entry): boolean =>
+  (typeof e?.command === 'string' && OWNED.test(e.command)) || OWNED.test(argsOf(e)[0] ?? '');
+const keyOf = (e: Entry): string => [String(e?.command ?? ''), ...argsOf(e)].join(' ');
+
+export interface HooksInstallReport {
+  settings: 'created' | 'updated' | 'unchanged' | 'unreadable';
+  launcher: 'written' | 'unchanged' | 'removed' | 'absent';
+  /** Hooks registered after this run. */
+  installed: string[];
+  /** sungen entries no longer registered (stale, or turned off). */
+  removed: number;
+  /** The backup written THIS run (only the first change writes one). */
+  backup?: string;
+  error?: string;
+}
+
+function hookEntry(hook: SungenHook): Record<string, unknown> {
+  return { type: 'command', command: 'node', args: [LAUNCHER_ARG, hook.name], ...(hook.meta.timeout ? { timeout: hook.meta.timeout } : {}) };
+}
+
+/** Pure: every sungen-owned entry removed, the wanted hooks appended, everything else as it was. */
+export function mergeSungenHooks(settings: Settings, wanted: SungenHook[]): Settings {
+  const hooks: Record<string, unknown> = { ...(settings.hooks ?? {}) };
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) continue; // readSettings refuses this shape; never rewrite it here
+    const kept = groups.flatMap((g) => {
+      const entries = entriesOf(g);
+      if (!entries || !entries.some(isOwned)) return [g];
+      const rest = entries.filter((e) => !isOwned(e));
+      return rest.length ? [{ ...(g as object), hooks: rest }] : [];
+    });
+    if (kept.length || !groups.length) hooks[event] = kept; else delete hooks[event];
+  }
+  for (const hook of wanted) {
+    for (const event of hook.meta.events) {
+      const matcher = hook.meta.matchers?.[event];
+      hooks[event] = [...(Array.isArray(hooks[event]) ? hooks[event] as unknown[] : []), { ...(matcher ? { matcher } : {}), hooks: [hookEntry(hook)] }];
+    }
+  }
+  const out: Settings = { ...settings };
+  if (Object.keys(hooks).length || settings.hooks !== undefined) out.hooks = hooks;
+  return out;
+}
+
+const ownedKeys = (s: Settings): string[] => Object.values(s.hooks ?? {})
+  .flatMap((groups) => (Array.isArray(groups) ? groups : []).flatMap((g) => entriesOf(g) ?? []))
+  .filter(isOwned).map(keyOf);
+
+/** The file's own indentation (a tab, or N spaces); 2 for a file that has none yet. */
+function indentOf(raw: string): string | number {
+  const m = raw.match(/^[{[][^\S\n]*\r?\n([ \t]+)\S/);
+  if (!m) return 2;
+  return m[1].startsWith('\t') ? '\t' : m[1].length;
+}
+
+function readSettings(file: string): { settings: Settings; indent: string | number } {
+  const raw = readTextFile(file);
+  const parsed: unknown = JSON.parse(raw);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('not a JSON object');
+  const hooks = (parsed as Settings).hooks;
+  if (hooks !== undefined && (!hooks || typeof hooks !== 'object' || Array.isArray(hooks))) throw new Error('"hooks" is not an object');
+  // An event that is not a list is a shape we cannot merge into without replacing it.
+  const odd = Object.entries(hooks ?? {}).find(([, groups]) => !Array.isArray(groups));
+  if (odd) throw new Error(`"hooks.${odd[0]}" is not a list`);
+  return { settings: parsed as Settings, indent: indentOf(raw) };
+}
+
+export function installClaudeHooks(cwd: string, opts: { dryRun?: boolean } = {}): HooksInstallReport {
+  const settingsPath = path.join(cwd, SETTINGS_REL);
+  const existed = fs.existsSync(settingsPath);
+  let current: Settings = {};
+  let indent: string | number = 2;
+  if (existed) {
+    try { ({ settings: current, indent } = readSettings(settingsPath)); } catch (e) {
+      return { settings: 'unreadable', launcher: 'absent', installed: [], removed: 0, error: `${SETTINGS_REL}: ${(e as Error).message.split('\n')[0]}` };
+    }
+  }
+  const off = configDisabledHooks(cwd);
+  const wanted = off === 'all' ? [] : allHooks().filter((h) => !off.has(h.name));
+  const merged = mergeSungenHooks(current, wanted);
+  const after = ownedKeys(merged);
+  const changed = existed ? JSON.stringify(merged) !== JSON.stringify(current) : wanted.length > 0;
+  const report: HooksInstallReport = {
+    settings: !changed ? 'unchanged' : existed ? 'updated' : 'created',
+    launcher: 'absent',
+    installed: wanted.map((h) => h.name),
+    removed: ownedKeys(current).filter((k) => !after.includes(k)).length,
+  };
+
+  const launcherPath = path.join(cwd, LAUNCHER_REL);
+  const onDisk = fs.existsSync(launcherPath) ? fs.readFileSync(launcherPath, 'utf8') : null;
+  const src = wanted.length ? fs.readFileSync(LAUNCHER_SRC, 'utf8') : null;
+  if (src !== null) report.launcher = onDisk === src ? 'unchanged' : 'written';
+  else if (onDisk !== null) report.launcher = 'removed';
+  if (opts.dryRun) return report;
+
+  const writeSettings = (): void => {
+    if (!changed) return;
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    const backup = settingsPath + BACKUP_SUFFIX;
+    if (existed && !fs.existsSync(backup)) { // keep the pristine original: never overwrite it
+      fs.copyFileSync(settingsPath, backup);
+      report.backup = SETTINGS_REL + BACKUP_SUFFIX;
+    }
+    writeFileAtomic(settingsPath, `${JSON.stringify(merged, null, indent)}\n`);
+  };
+  // settings.json must never point at a launcher that is not there: install the launcher BEFORE the
+  // entries that run it, and remove it only AFTER the entries are gone.
+  if (src !== null) {
+    if (onDisk !== src) { fs.mkdirSync(path.dirname(launcherPath), { recursive: true }); writeFileAtomic(launcherPath, src); }
+    writeSettings();
+  } else {
+    writeSettings();
+    if (onDisk !== null) fs.rmSync(launcherPath, { force: true });
+  }
+  return report;
+}
+
+/** One summary line for init/update output. */
+export function describeHooksInstall(r: HooksInstallReport): string {
+  if (r.settings === 'unreadable') return `${r.error} — Claude Code hooks not installed; fix the JSON and re-run`;
+  const what = r.installed.length ? `Claude Code hooks: ${r.installed.join(', ')}` : 'Claude Code hooks: none (turned off in qa/sungen.config.yaml)';
+  const extra = [r.removed ? `${r.removed} stale removed` : '', r.backup ? `backup ${r.backup}` : ''].filter(Boolean).join(', ');
+  return `${SETTINGS_REL} (${what}${extra ? `; ${extra}` : ''})`;
+}

package/src/orchestrator/flow-manager.ts

@@ -8,7 +8,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { readCapabilities } from '../harness/capability';
 import { testDataHeader, ensureTestDataGuideFiles } from './test-data-guide';
-import { viewpointScaffold } from './viewpoint-scaffold';
 
 export interface FlowOptions {
   name: string;
@@ -144,7 +143,7 @@ export class FlowManager {
     fs.writeFileSync(specPath, this.generateSpecTemplate(options, flowName, isMobile), 'utf-8');
 
     const viewpointPath = path.join(requirementsDir, 'test-viewpoint.md');
-    fs.writeFileSync(viewpointPath, viewpointScaffold(`${options.name} Flow`, isMobile), 'utf-8');
+    fs.writeFileSync(viewpointPath, this.generateViewpointTemplate(options), 'utf-8');
 
     console.log(`Created files:`);
     console.log(`  ${path.relative(this.cwd, featurePath)}`);
@@ -218,7 +217,7 @@ export class FlowManager {
       restored.push(file);
     };
     ensure(path.join(paths.requirementsDir, 'spec.md'), () => this.generateSpecTemplate(options, flowName, isMobile));
-    ensure(path.join(paths.requirementsDir, 'test-viewpoint.md'), () => viewpointScaffold(`${options.name} Flow`, isMobile));
+    ensure(path.join(paths.requirementsDir, 'test-viewpoint.md'), () => this.generateViewpointTemplate(options));
     ensure(paths.featurePath, () => this.generateFeatureTemplate(options, flowName, isMobile));
     return restored;
   }
@@ -288,6 +287,57 @@ export class FlowManager {
 `;
   }
 
+  private generateViewpointTemplate(options: FlowOptions): string {
+    return [
+      `# ${options.name} Flow — Test Viewpoints`,
+      '',
+      '## Edge Cases',
+      '',
+      '<!-- Sample — replace with actual edge cases for this flow:',
+      '- Network drops between screen transitions — should resume or show error?',
+      '- Session expires mid-flow — should redirect to login and preserve progress?',
+      '- Browser back button at step 3 — should return to step 2 with data intact?',
+      '- Complete flow twice rapidly — should prevent duplicate submissions',
+      '-->',
+      '',
+      '## Known Issues',
+      '',
+      '<!-- Sample — replace with actual known issues:',
+      '- [BUG-001] Form data lost if user navigates away and returns',
+      '- [BUG-002] Confirmation page shows stale data on slow connections',
+      '-->',
+      '',
+      '## Design Decisions',
+      '',
+      '<!-- Sample — replace with actual design decisions:',
+      '- Flow requires completing all steps in order (no skip)',
+      '- Draft is auto-saved at each step transition',
+      '- Cancel at any step discards the entire flow',
+      '-->',
+      '',
+      '## Cross-Screen Concerns',
+      '',
+      '<!-- Sample — replace with actual cross-screen concerns:',
+      '- Auth role must remain consistent across all screens',
+      '- Data entered in step 1 must be visible in confirmation (step 3)',
+      '- Error in step 2 should allow returning to step 1 without re-entering data',
+      '-->',
+      '',
+      '## Priority Viewpoints',
+      '',
+      '<!-- Rate importance for this flow (High / Medium / Low / Skip):',
+      '',
+      '| VP | Priority | Reason |',
+      '|---|----------|--------|',
+      '| VP-UI | Medium | Standard forms across screens |',
+      '| VP-VAL | High | Cross-screen validation rules |',
+      '| VP-LOGIC | High | Multi-step business logic, state transitions |',
+      '| VP-SEC | Medium | Auth must persist, role-based access at each screen |',
+      '-->',
+      '',
+    ].join('\n');
+  }
+
   private generateFeatureTemplate(options: FlowOptions, flowName: string, isMobile: boolean): string {
     const description = options.description || `complete the ${options.name} flow`;
 

package/src/orchestrator/lockstep-version.ts

@@ -18,29 +18,42 @@ export function coreVersion(): string {
 /**
  * Resolve the version to install for a family package, given the running `core` version.
  *
- * Lockstep wants the EXACT `core` version. But the beta channel publishes `<core>-beta.N` before a
- * stable `<core>` ever exists — so a released core (e.g. 3.2.10) asking for `@3.2.10` hits ETARGET
- * out-of-the-box when npm only has `3.2.10-beta.2` (`sungen capability add` then fails for a fresh
- * user). Fall back on the SAME version line: prefer exact `core`, else the highest `core-beta.N`,
- * else the `beta` dist-tag as a last resort. Keeps the driver's pinned core-dep on the same line.
+ * Lockstep wants the EXACT `core` version. But the prerelease channels publish `<core>-beta.N`
+ * (beta branch) and `<core>-alpha.N` (alpha branch) before a stable `<core>` ever exists — so a
+ * released core (e.g. 3.2.10) asking for `@3.2.10` hits ETARGET out-of-the-box when npm only has
+ * `3.2.10-beta.2` (`sungen capability add` then fails for a fresh user). Fall back on the SAME
+ * version line — see `pickDriverVersion`. Keeps the driver's pinned core-dep on the same line.
  */
 export function resolveDriverVersion(pkg: string, core: string): string {
   if (core === 'latest') return 'beta';
   try {
     const out = spawnSync('npm', ['view', pkg, 'versions', '--json'], { encoding: 'utf-8', shell: true });
     if (out.status !== 0 || !out.stdout) return core; // can't query → let the exact install try/fail
-    let versions: string[] = [];
     const parsed = JSON.parse(out.stdout);
-    versions = Array.isArray(parsed) ? parsed : [parsed];
-    if (versions.includes(core)) return core; // exact exists → lockstep
-    const prefix = `${core}-beta.`;
-    const betas = versions
-      .filter((v) => typeof v === 'string' && v.startsWith(prefix))
-      .map((v) => parseInt(v.slice(prefix.length), 10))
-      .filter((n) => Number.isInteger(n));
-    if (betas.length) return `${core}-beta.${Math.max(...betas)}`; // highest same-line prerelease
-    return 'beta'; // nothing on this line → newest beta dist-tag
+    return pickDriverVersion(Array.isArray(parsed) ? parsed : [parsed], core);
   } catch {
     return core;
   }
 }
+
+/**
+ * Pick from a package's published `versions`: the exact `core`, else the highest same-line
+ * prerelease of core's OWN channel, else that channel's dist-tag. The channel is `alpha` for an
+ * alpha core and `beta` for any other (stable or beta): a stable or beta core never takes an alpha
+ * driver — alpha builds are the next big update, and an alpha driver pins an alpha core.
+ *
+ * The line is core without its prerelease suffix (as `sameVersionLine` in capabilities/discover.ts
+ * reads it), so `3.3.0-alpha.4` with no exact driver still finds `3.3.0-alpha.3`.
+ */
+export function pickDriverVersion(versions: readonly string[], core: string): string {
+  if (versions.includes(core)) return core; // exact exists → lockstep
+  const channel = /-alpha(\.|$)/.test(core) ? 'alpha' : 'beta';
+  const line = core.split('-')[0];
+  const prefix = `${line}-${channel}.`;
+  const indexes = versions
+    .filter((v) => typeof v === 'string' && v.startsWith(prefix))
+    .map((v) => parseInt(v.slice(prefix.length), 10))
+    .filter((n) => Number.isInteger(n));
+  if (indexes.length) return `${line}-${channel}.${Math.max(...indexes)}`; // highest same-line prerelease
+  return channel; // nothing on this line → newest build of core's channel
+}

package/src/orchestrator/project-initializer.ts

@@ -18,6 +18,7 @@ import {
 } from './mobile-runtime-scaffolder';
 import { emitAppiumEnvironment, runAppiumEnvironmentSetup, appiumEnvironmentRerunCommand } from './appium-environment-setup';
 import { ensureSecurityOverrides, reportSecurityOverrides } from './security-overrides';
+import { installClaudeHooks, describeHooksInstall } from './claude-hooks-install';
 import { readTextFile } from '../harness/read-text';
 
 export { MobileInitOptions };
@@ -198,6 +199,12 @@ export class ProjectInitializer {
     // Create root .mcp.json for Claude Code
     this.createClaudeMCPConfig();
 
+    // Claude Code hooks (hand-back on Stop, unit state on SessionStart, approval-path guard),
+    // merged into .claude/settings.json — only when Claude is a selected assistant.
+    if (this.agents.includes('claude')) {
+      this.createClaudeHooks();
+    }
+
     // Create .codex/config.toml for Codex CLI — only when Codex is a selected assistant
     // (`sungen init --assistant codex`), since it is Codex-specific config.
     if (this.agents.includes('codex')) {
@@ -397,6 +404,20 @@ export class ProjectInitializer {
     );
   }
 
+  /**
+   * Merge sungen's Claude Code hooks into `.claude/settings.json` (user hooks kept, backup before
+   * any change, unreadable file left alone — see claude-hooks-install.ts). A no-op for a project
+   * without Claude.
+   */
+  private createClaudeHooks(): void {
+    if (!this.agents.includes('claude')) return;
+    const r = installClaudeHooks(this.cwd);
+    const line = describeHooksInstall(r);
+    if (r.settings === 'unreadable') this.notDoneItems.push(line);
+    else if (r.settings === 'unchanged') this.skippedItems.push(line);
+    else this.createdItems.push(line);
+  }
+
   /**
    * Create `.codex/config.toml` for Codex CLI — the Codex analog of `.mcp.json` (Claude) and
    * `.vscode/mcp.json` (Copilot), so `sungen run-test` under Codex drives the same live Playwright

package/src/orchestrator/screen-manager.ts

@@ -8,7 +8,7 @@ import * as path from 'path';
 import { readCapabilities } from '../harness/capability';
 import { testDataHeader, ensureTestDataGuideFiles } from './test-data-guide';
 import { resolveWebBaseUrl } from '../exporters/env-qa';
-import { viewpointScaffold } from './viewpoint-scaffold';
+import { uiPatternRows } from './viewpoint-pattern-catalog';
 
 export interface ScreenOptions {
   name: string;
@@ -158,11 +158,59 @@ export class ScreenManager {
       fs.writeFileSync(specPath, this.generateSpecTemplate(options, screenName), 'utf-8');
     }
 
-    // Generate requirements test-viewpoint.md (only on first screen creation): the QA template,
-    // samples inside comments, so an untouched file declares nothing (see viewpoint-scaffold.ts).
+    // Generate requirements test-viewpoint.md (only on first screen creation)
     const viewpointPath = path.join(requirementsDir, 'test-viewpoint.md');
     if (!fs.existsSync(viewpointPath)) {
-      fs.writeFileSync(viewpointPath, viewpointScaffold(options.name, isMobile), 'utf-8');
+      fs.writeFileSync(viewpointPath, [
+        `# ${options.name} — Test Viewpoints`,
+        '',
+        '## Edge Cases',
+        '',
+        '<!-- Sample — replace with actual edge cases for this screen:',
+        '- Paste emoji into text fields (e.g., 🎉👋) — should accept or sanitize?',
+        '- Input 10,000+ characters into free text — truncate or reject?',
+        '- Double-click Submit rapidly — should only create 1 record',
+        '- Browser back button after successful submit — should not re-submit',
+        '-->',
+        '',
+        '## Known Issues',
+        '',
+        '<!-- Sample — replace with actual known issues:',
+        '- [BUG-001] Date picker does not work on Safari < 16',
+        '- [BUG-002] File upload silently fails for files > 20MB (no error shown)',
+        '- Search does not handle Vietnamese accents correctly ("Nguyên" ≠ "Nguyen")',
+        '-->',
+        '',
+        '## Design Decisions',
+        '',
+        '<!-- Sample — replace with actual design decisions:',
+        '- Show all validation errors at once (not one at a time) — per UX review',
+        '- Cancel button resets form completely (no draft saving)',
+        '- Anonymous mode hides sender name but keeps department visible',
+        '-->',
+        '',
+        '## UI Patterns Identified',
+        '',
+        '<!-- Check applicable patterns for this screen (numbered as in the sungen-viewpoint skill):',
+        '',
+        '| # | Pattern | Applicable? | Notes |',
+        '|---|---------|-------------|-------|',
+        ...uiPatternRows(isMobile),
+        '-->',
+        '',
+        '## Priority Viewpoints',
+        '',
+        '<!-- Rate importance for this screen (High / Medium / Low / Skip):',
+        '',
+        '| VP | Priority | Reason |',
+        '|---|----------|--------|',
+        '| VP-UI | High | Complex form with many states |',
+        '| VP-VAL | High | 14 validation rules from spec |',
+        '| VP-LOGIC | Medium | Standard CRUD, no complex business rules |',
+        '| VP-SEC | Low | Internal tool, basic auth only |',
+        '-->',
+        '',
+      ].join('\n'), 'utf-8');
     }
 
     // Auto-screenshot: capture page only when --capture is set and not mobile (requires --path)

package/src/orchestrator/templates/ai-src/commands/add-api.md

@@ -7,6 +7,8 @@ claude-tools: "Read, Grep, Bash, Glob, Edit, Write, AskUserQuestion"
 copilot-tools: "[vscode, execute, read, agent, edit, search, todo]"
 codex-trigger: "Run when the user asks to add or scaffold a NEW API area/resource or an API flow to test (REST/HTTP endpoints, not a UI screen). Step 1 of the API workflow. Do NOT use for UI screens, flows across screens, creating test cases, or running tests."
 ---
+<!-- include: hand-back-rule -->
+
 {{^cap parallel-subagents}}
 **Input**: an API area name (a resource/tag, e.g. `orders`, `users`) and the base URL:
 `/sungen-add-api orders --base-url https://api.example.com`.

package/src/orchestrator/templates/ai-src/commands/add-flow.md

@@ -7,6 +7,8 @@ claude-tools: "Read, Grep, Bash, Glob, Edit, Write, AskUserQuestion, mcp__playwr
 copilot-tools: "[vscode, execute, read, agent, edit, search, todo]"
 codex-trigger: "Run when the user asks to add a NEW cross-screen end-to-end flow. Step 1 (flow variant). Do NOT use for a single screen, creating test cases, or running tests."
 ---
+<!-- include: hand-back-rule -->
+
 {{^cap parallel-subagents}}
 **Input**: Flow name and optional starting URL (e.g., `/sungen-add-flow award-submission --path /login`).
 

package/src/orchestrator/templates/ai-src/commands/add-screen.md

@@ -7,6 +7,8 @@ claude-tools: "Read, Grep, Bash, Glob, Edit, Write, AskUserQuestion, mcp__playwr
 copilot-tools: "[vscode, execute, read, agent, edit, search, web, browser, todo, 'playwright/*']"
 codex-trigger: "Run when the user asks to add or scaffold a NEW screen/page to test. Step 1 of the sungen workflow. Do NOT use for flows, creating test cases, or running tests."
 ---
+<!-- include: hand-back-rule -->
+
 {{^cap parallel-subagents}}
 **Input**: Screen name and URL path (e.g., `/sungen-add-screen login /login`).
 Optionally include a Figma URL: `/sungen-add-screen login /login --figma https://www.figma.com/design/...`.

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

@@ -7,6 +7,7 @@ claude-tools: "Read, Grep, Bash, Glob, Write, Edit, AskUserQuestion, Skill"
 copilot-tools: "[vscode, execute, read, agent, edit, search, todo]"
 codex-trigger: "Run when the user asks to CREATE, generate, or standardize TEST DATA / test values for a screen or flow (valid/boundary/invalid, boundary values, negative data). Uses the Data Factory driver. Not for generating the .feature scenarios themselves (that is create-test)."
 ---
+<!-- include: hand-back-rule -->
 
 **Input**: A screen or flow name (e.g., `/sungen:create-data-test login`), OR **no name** to do every unit (with a confirmation — see ALL mode). Load the `sungen-data-factory` skill for the full method.