@aurorajs.dev/catalyst-cli 1.0.0

package/dist/templates/monorepo/.claude/scripts/generate-skills-index.ts

@@ -0,0 +1,403 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ─── Interfaces ───────────────────────────────────────────────
+interface SkillGroup {
+  /** Relative path from .claude/ (e.g. "skills/aurora-cqrs") */
+  relativePath: string;
+  /** .md files found in this group */
+  files: string[];
+}
+
+interface IndexResult {
+  groups: SkillGroup[];
+  totalSkills: number;
+  totalCommands: number;
+  totalAgents: number;
+  totalFiles: number;
+}
+
+interface ProjectResult {
+  /** Project directory name (e.g. "backend", "frontend", or "root") */
+  name: string;
+  /** Absolute path to the project directory */
+  projectDir: string;
+  /** Index generation result */
+  stats: IndexResult;
+}
+
+interface ValidationWarning {
+  path: string;
+  message: string;
+}
+
+// ─── Constants ────────────────────────────────────────────────
+// Script lives in .claude/scripts/, so __dirname/../.. = monorepo root
+const MONOREPO_ROOT = path.resolve(__dirname, '..', '..');
+const MARKER_START = '<!-- catalyst-ai:skills-index -->';
+const MARKER_END = '<!-- /catalyst-ai:skills-index -->';
+const DEBOUNCE_MS = 500;
+
+// ─── Project discovery ───────────────────────────────────────
+
+/** Discover all projects in the monorepo that have both .claude/ and CLAUDE.md */
+function discoverProjects(): { name: string; projectDir: string }[] {
+  const projects: { name: string; projectDir: string }[] = [];
+
+  // Root project
+  const rootClaudeDir = path.join(MONOREPO_ROOT, '.claude');
+  const rootClaudeMd = path.join(MONOREPO_ROOT, 'CLAUDE.md');
+  if (fs.existsSync(rootClaudeDir) && fs.existsSync(rootClaudeMd)) {
+    projects.push({ name: 'root', projectDir: MONOREPO_ROOT });
+  }
+
+  // Scan immediate subdirectories
+  const entries = fs.readdirSync(MONOREPO_ROOT, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+    const projectDir = path.join(MONOREPO_ROOT, entry.name);
+    const claudeDir = path.join(projectDir, '.claude');
+    const claudeMd = path.join(projectDir, 'CLAUDE.md');
+
+    if (fs.existsSync(claudeDir) && fs.existsSync(claudeMd)) {
+      projects.push({ name: entry.name, projectDir });
+    }
+  }
+
+  return projects;
+}
+
+// ─── Scanning functions ───────────────────────────────────────
+
+/** Recursively find .md files, ignoring logs/ and scripts/ */
+function scanMdFiles(dir: string, baseDir: string): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const rel = path.relative(baseDir, fullPath);
+
+    // Skip logs and scripts directories
+    if (rel.startsWith('logs') || rel.startsWith('scripts')) continue;
+
+    if (entry.isDirectory()) {
+      results.push(...scanMdFiles(fullPath, baseDir));
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      results.push(rel);
+    }
+  }
+  return results;
+}
+
+/** Group files by category and subfolder */
+function groupFiles(files: string[]): SkillGroup[] {
+  const groupMap = new Map<string, string[]>();
+
+  for (const file of files) {
+    const parts = file.split(path.sep);
+
+    let groupKey: string;
+    if (parts[0] === 'skills' && parts.length > 2) {
+      // skills/aurora-cqrs/SKILL.md → "skills/aurora-cqrs"
+      groupKey = `${parts[0]}/${parts[1]}`;
+    } else if (
+      parts[0] === 'agents' &&
+      parts.length > 2 &&
+      parts[1] === 'assets'
+    ) {
+      // agents/assets/phone-patterns.md → "agents/assets"
+      groupKey = 'agents/assets';
+    } else {
+      // commands/create-skill.md → "commands"
+      // agents/catalyst-schema-manager.md → "agents"
+      groupKey = parts[0];
+    }
+
+    if (!groupMap.has(groupKey)) groupMap.set(groupKey, []);
+    groupMap.get(groupKey)!.push(parts[parts.length - 1]);
+  }
+
+  // Sort groups: skills/* first, then the rest
+  const sortedKeys = [...groupMap.keys()].sort((a, b) => {
+    const catOrder = (k: string) => {
+      if (k.startsWith('skills/')) return 0;
+      if (k === 'commands') return 1;
+      if (k.startsWith('agents')) return 2;
+      return 3;
+    };
+    const diff = catOrder(a) - catOrder(b);
+    return diff !== 0 ? diff : a.localeCompare(b);
+  });
+
+  return sortedKeys.map((key) => {
+    const rawFiles = groupMap.get(key)!;
+    // SKILL.md first, then alphabetical
+    const sorted = rawFiles.sort((a, b) => {
+      if (a === 'SKILL.md') return -1;
+      if (b === 'SKILL.md') return 1;
+      return a.localeCompare(b);
+    });
+    // Remove duplicates
+    const unique = [...new Set(sorted)];
+    return { relativePath: key, files: unique };
+  });
+}
+
+/** Generate the full compressed index */
+function generateIndex(groups: SkillGroup[]): string {
+  const header =
+    '[Project Skills Index]|root:.claude|IMPORTANT:Prefer retrieval-led reasoning over pre-training.Read SKILL.md first,then related files.';
+  const lines = groups.map((g) => `|${g.relativePath}:{${g.files.join(',')}}`);
+  return MARKER_START + '\n' + header + lines.join('') + '\n' + MARKER_END;
+}
+
+/** Compute statistics from grouped results */
+function computeStats(groups: SkillGroup[]): IndexResult {
+  let totalSkills = 0;
+  let totalCommands = 0;
+  let totalAgents = 0;
+  let totalFiles = 0;
+
+  for (const g of groups) {
+    totalFiles += g.files.length;
+    if (g.relativePath.startsWith('skills/')) totalSkills++;
+    else if (g.relativePath === 'commands') totalCommands = g.files.length;
+    else if (g.relativePath.startsWith('agents')) totalAgents++;
+  }
+
+  return { groups, totalSkills, totalCommands, totalAgents, totalFiles };
+}
+
+// ─── CLAUDE.md injection ──────────────────────────────────────
+
+function injectIndex(claudeMdPath: string, index: string): void {
+  let content: string;
+
+  if (fs.existsSync(claudeMdPath)) {
+    content = fs.readFileSync(claudeMdPath, 'utf-8');
+  } else {
+    content = '';
+  }
+
+  const startIdx = content.indexOf(MARKER_START);
+  const endIdx = content.indexOf(MARKER_END);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    // Replace between markers
+    content =
+      content.substring(0, startIdx) +
+      index +
+      content.substring(endIdx + MARKER_END.length);
+  } else {
+    // Append at end
+    content = content.trimEnd() + '\n\n' + index + '\n';
+  }
+
+  fs.writeFileSync(claudeMdPath, content, 'utf-8');
+}
+
+// ─── Validation ───────────────────────────────────────────────
+
+function validate(groups: SkillGroup[]): ValidationWarning[] {
+  const warnings: ValidationWarning[] = [];
+
+  for (const g of groups) {
+    if (!g.relativePath.startsWith('skills/')) continue;
+
+    if (!g.files.includes('SKILL.md')) {
+      warnings.push({
+        path: g.relativePath,
+        message: 'SKILL.md not found',
+      });
+    } else if (g.files.length === 1) {
+      warnings.push({
+        path: g.relativePath,
+        message: 'only contains SKILL.md (consider adding more docs)',
+      });
+    }
+  }
+
+  return warnings;
+}
+
+// ─── Watch mode ───────────────────────────────────────────────
+
+function watchMode(verbose: boolean): void {
+  console.log('👀 Watching for changes in all .claude/ directories...');
+
+  let timeout: NodeJS.Timeout | null = null;
+
+  const regenerate = (event?: string, filename?: string) => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      const timestamp = new Date().toLocaleTimeString('en-US', {
+        hour12: false,
+      });
+      if (filename) {
+        console.log(`[${timestamp}] Change detected: ${filename}`);
+      }
+      const results = runAll(false, false, verbose);
+      for (const r of results) {
+        console.log(
+          `[${timestamp}] ✓ ${r.name}: ${r.stats.totalSkills} skills, ${r.stats.totalCommands} commands, ${r.stats.totalAgents} agents`,
+        );
+      }
+    }, DEBOUNCE_MS);
+  };
+
+  // Watch all .claude directories
+  const projects = discoverProjects();
+  for (const project of projects) {
+    const claudeDir = path.join(project.projectDir, '.claude');
+    try {
+      fs.watch(claudeDir, { recursive: true }, (event, filename) => {
+        if (filename?.endsWith('.md')) {
+          regenerate(event, `${project.name}/${filename}`);
+        }
+      });
+    } catch {
+      // Directory might not support recursive watch
+    }
+  }
+
+  if (verbose) {
+    console.log(
+      `  Watching ${projects.length} project(s): ${projects.map((p) => p.name).join(', ')}`,
+    );
+  }
+
+  // Clean Ctrl+C exit
+  process.on('SIGINT', () => {
+    console.log('\n✓ Watch stopped');
+    process.exit(0);
+  });
+}
+
+// ─── Single project run ──────────────────────────────────────
+
+function runProject(
+  project: { name: string; projectDir: string },
+  dryRun: boolean,
+  validateFlag: boolean,
+  verbose: boolean,
+): ProjectResult {
+  const claudeDir = path.join(project.projectDir, '.claude');
+  const claudeMd = path.join(project.projectDir, 'CLAUDE.md');
+
+  const files = scanMdFiles(claudeDir, claudeDir);
+  const groups = groupFiles(files);
+  const stats = computeStats(groups);
+  const index = generateIndex(groups);
+
+  if (verbose) {
+    console.log(`\n  [${project.name}]`);
+    console.log(`    .claude dir: ${claudeDir}`);
+    console.log(`    .md files found: ${files.length}`);
+    console.log(`    Groups generated: ${groups.length}`);
+    for (const g of groups) {
+      console.log(`      ${g.relativePath}: ${g.files.join(', ')}`);
+    }
+  }
+
+  if (validateFlag) {
+    const warnings = validate(groups);
+    for (const g of groups) {
+      if (g.relativePath.startsWith('skills/')) {
+        const w = warnings.find((w) => w.path === g.relativePath);
+        if (w) {
+          console.log(`  ⚠ [${project.name}] ${g.relativePath}: ${w.message}`);
+        } else {
+          console.log(
+            `  ✓ [${project.name}] ${g.relativePath}: SKILL.md found (${g.files.length} files)`,
+          );
+        }
+      }
+    }
+  }
+
+  if (dryRun) {
+    console.log(`[dry-run] [${project.name}] Index generated (not written):`);
+    console.log(index);
+  } else {
+    injectIndex(claudeMd, index);
+  }
+
+  return { name: project.name, projectDir: project.projectDir, stats };
+}
+
+// ─── Main execution ───────────────────────────────────────────
+
+function runAll(
+  dryRun: boolean,
+  validateFlag: boolean,
+  verbose: boolean,
+): ProjectResult[] {
+  const projects = discoverProjects();
+  const results: ProjectResult[] = [];
+
+  for (const project of projects) {
+    results.push(runProject(project, dryRun, validateFlag, verbose));
+  }
+
+  if (!dryRun && !validateFlag) {
+    for (const r of results) {
+      console.log(
+        `✓ ${r.name}: ${r.stats.totalSkills} skills, ${r.stats.totalCommands} commands, ${r.stats.totalAgents} agents`,
+      );
+    }
+    console.log(`✓ ${results.length} CLAUDE.md files updated`);
+  }
+
+  return results;
+}
+
+// ─── CLI ──────────────────────────────────────────────────────
+
+function main(): void {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help')) {
+    console.log(`
+Usage: npx tsx .claude/scripts/generate-skills-index.ts [options]
+
+Scans all project directories in the monorepo that have a .claude/ directory
+and a CLAUDE.md file. For each one, generates a skills index from its .claude/
+contents and injects it into its CLAUDE.md between the marker comments.
+
+Flags:
+  --dry-run     Show index in console without writing to CLAUDE.md
+  --watch       Watch all .claude/ dirs for changes and regenerate automatically
+  --validate    Verify each skill has SKILL.md, report warnings
+  --verbose     Show detailed process information
+  --help        Show help
+
+Examples:
+  npx tsx .claude/scripts/generate-skills-index.ts --dry-run --validate
+  npx tsx .claude/scripts/generate-skills-index.ts --watch --verbose
+`);
+    return;
+  }
+
+  const dryRun = args.includes('--dry-run');
+  const validateFlag = args.includes('--validate');
+  const verbose = args.includes('--verbose');
+  const watch = args.includes('--watch');
+
+  // Initial run
+  runAll(dryRun, validateFlag, verbose);
+
+  // Watch mode
+  if (watch) {
+    watchMode(verbose);
+  }
+}
+
+main();

package/dist/templates/monorepo/.claude/scripts/status-line.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+input=$(cat)
+MODEL=$(echo "$input" | jq -r '.model.display_name')
+DIR=$(echo "$input" | jq -r '.workspace.current_dir' | rev | cut -d/ -f1 | rev)
+PERCENT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
+
+# Dev mode from project root
+MODE_FILE=".catalyst-dev-mode"
+if [ -f "$MODE_FILE" ]; then
+  MODE=$(tr -d '[:space:]' < "$MODE_FILE")
+else
+  MODE="Solution"
+fi
+
+echo "[$MODEL] 📁 $DIR | 🧠 ${PERCENT}% | ⚙️ $MODE"

package/dist/templates/monorepo/.claude/settings.json

@@ -0,0 +1,120 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx tsx \"$CLAUDE_PROJECT_DIR/.claude/scripts/generate-skills-index.ts\"",
+            "timeout": 30
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/scripts/daily-tip.sh",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/scripts/catalyst-dev-mode.sh",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "npx tsx \"$CLAUDE_PROJECT_DIR/.claude/hooks/check-required-plugins.ts\"",
+            "timeout": 15
+          }
+        ]
+      },
+      {
+        "matcher": "startup|clear",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "rm -f \"$CLAUDE_PROJECT_DIR/.claude/.cache/architecture-checkpoint.txt\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx tsx \"$CLAUDE_PROJECT_DIR/.claude/hooks/inject-rules-context.ts\"",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx tsx \"$CLAUDE_PROJECT_DIR/.claude/hooks/architecture-checkpoint.ts\"",
+            "timeout": 15
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx tsx \"$CLAUDE_PROJECT_DIR/.claude/hooks/harness-rules-content-guard.ts\"",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": {
+    "type": "command",
+    "command": ".claude/scripts/status-line.sh"
+  },
+  "enabledPlugins": {
+    "context7@claude-plugins-official": true,
+    "engram@engram": true,
+    "superpowers@claude-plugins-official": true,
+    "code-review@claude-plugins-official": true
+  },
+  "extraKnownMarketplaces": {
+    "engram": {
+      "source": {
+        "source": "github",
+        "repo": "Gentleman-Programming/engram"
+      }
+    }
+  },
+  "permissions": {
+    "allow": [
+      "Bash(aurora load:*)",
+      "Bash(find:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git restore:*)",
+      "Bash(git push:*)",
+      "Bash(git log:*)",
+      "Bash(git diff:*)",
+      "Bash(git status:*)",
+      "Bash(git branch:*)",
+      "Bash(git rev-parse:*)",
+      "Bash(git symbolic-ref:*)",
+      "Bash(grep:*)",
+      "Bash(fd:*)",
+      "Bash(gh auth:*)",
+      "Bash(gh pr:*)",
+      "Bash(npm run format:*)",
+      "Bash(npm test:*)",
+      "Bash(npx prettier:*)",
+      "Bash(npx tsc:*)",
+      "Skill(conventional-commits)",
+      "Skill(commit)",
+      "Skill(commit-pr)"
+    ]
+  }
+}

package/dist/templates/monorepo/.claude/skills/REGISTRY.md

@@ -0,0 +1,128 @@
+# Skill Registry — Aurora Catalyst
+
+A navigable catalog of the project's skills, organized by **scope** (physical location) and within
+each scope by **type**. Each `SKILL.md` is the source of truth — this file is only the index.
+
+**Sync rule**: after creating, editing, or deleting any skill, regenerate this file so it reflects
+the real state.
+
+## How to use this registry
+
+1. Detect the **scope** of your task (monorepo, frontend, backend) — usually the first thing you
+   know
+2. Go to the matching section and locate the applicable skill type
+3. Read the `SKILL.md` BEFORE writing code
+4. Multiple skills may apply at once — read them all and combine their rules
+
+---
+
+## Monorepo (`.claude/skills/`)
+
+Apply to the whole project, stack-agnostic.
+
+### Aurora Domain
+
+| Skill                   | Trigger                                                                                                                                                                                                | Path                                            |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------- |
+| `business-rules-guard`  | Adding, modifying, or derogating business rules; rule cited or asked about by `BR-<BC>-<AGGREGATE>-<NNN>`; about to touch code of an aggregate with active rules; any `/business-rules:*` command run  | `.claude/skills/business-rules-guard/SKILL.md`  |
+| `catalyst-cli`          | Running `catalyst …` commands, regenerating a module, reconciling `.origin` files, deciding whether a change belongs in YAML or in code, post-schema-edit workflows                                    | `.claude/skills/catalyst-cli/SKILL.md`          |
+| `catalyst-schema`       | Analyzing or editing `*.aurora.yaml` files, validating naming, descriptions, and DDD semantics                                                                                                         | `.claude/skills/catalyst-schema/SKILL.md`       |
+| `harness-rules-guard`   | An HR rule cited or asked about by `HR-<TOPIC>-<NNN>`; about to touch paths governed by an active harness rule; during `/opsx:propose` (declaring `## Harness rules applicable`); files under `cliter/harness-rules/`  | `.claude/skills/harness-rules-guard/SKILL.md`   |
+
+### Code Quality
+
+| Skill        | Trigger                                                                                                   | Path                                 |
+| ------------ | --------------------------------------------------------------------------------------------------------- | ------------------------------------ |
+| `judgment-day` | Blind dual / adversarial review of a diff ("judgment day", "dual review", "juzgar"): two independent judges, fix confirmed issues, then re-judge | `.claude/skills/judgment-day/SKILL.md` |
+| `typescript` | Implementing or refactoring TS in `.ts`/`.tsx` (types, interfaces, generics, type guards, removing `any`) | `.claude/skills/typescript/SKILL.md` |
+
+### Workflow — OpenSpec SDD
+
+| Skill                     | Trigger                                                            | Path                                              |
+| ------------------------- | ------------------------------------------------------------------ | ------------------------------------------------- |
+| `openspec-propose`        | Create a new change proposal with all artifacts in one step        | `.claude/skills/openspec-propose/SKILL.md`        |
+| `openspec-explore`        | Think through an idea or investigate before committing to a change | `.claude/skills/openspec-explore/SKILL.md`        |
+| `openspec-apply-change`   | Implement the tasks of an existing change                          | `.claude/skills/openspec-apply-change/SKILL.md`   |
+| `openspec-archive-change` | Finalize and archive a change after implementation                 | `.claude/skills/openspec-archive-change/SKILL.md` |
+
+### Meta
+
+| Skill                            | Trigger                                                                          | Path                                                     |
+| -------------------------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| `catalyst-skill-creator`         | Create new skills following the Agent Skills spec, document AI patterns          | `.claude/skills/catalyst-skill-creator/SKILL.md`         |
+| `catalyst-update-skill-registry` | Regenerate this `REGISTRY.md` after creating/editing/deleting/renaming any skill | `.claude/skills/catalyst-update-skill-registry/SKILL.md` |
+
+---
+
+## Frontend (`frontend/.claude/skills/`)
+
+Angular-specific.
+
+### UI & Components
+
+| Skill                               | Trigger                                                                                                                                                                                                                     | Path                                                                 |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| `catalyst-component-catalog`        | **Consume** `@aurora/components`: compose UI, generate screens, pick between existing components by reading `*.stories.ts`. Solution mode.                                                                                  | `frontend/.claude/skills/catalyst-component-catalog/SKILL.md`        |
+| `catalyst-component-story-composer` | **Author** stories for `@aurora/components`: add a new component, update a stale story, batch-document. Three-phase procedure (extract facts from `.ts` → demand intent from dev → write + `tsc --noEmit`). Framework mode. | `frontend/.claude/skills/catalyst-component-story-composer/SKILL.md` |
+| `catalyst-data-table-management`    | Define columns, render cells, reactive translations, table infrastructure (TanStack + Spartan)                                                                                                                              | `frontend/.claude/skills/catalyst-data-table-management/SKILL.md`    |
+| `catalyst-form-composer-auditor`    | Compose or audit `*-detail.component.ts` / `*-form.component.ts` components (COMPOSE or AUDIT mode)                                                                                                                         | `frontend/.claude/skills/catalyst-form-composer-auditor/SKILL.md`    |
+| `spartan-ng` | Add, search, compose, style, or debug Spartan UI (Brain/Helm); `@spartan-ng/*` imports, `nx generate @spartan-ng/cli:ui`, or any Angular project with Spartan installed | `frontend/.claude/skills/spartan/SKILL.md` |
+
+### Data Access
+
+| Skill                 | Trigger                                                                                                                                                     | Path                                                   |
+| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
+| `catalyst-data-layer` | Wire components / resolvers / ad-hoc code to `@aurora/modules/graphql` (fetchers vs composables, query/mutate, resolver pattern, `pickModel`, escape hatch) | `frontend/.claude/skills/catalyst-data-layer/SKILL.md` |
+
+### Layout & Design
+
+| Skill                  | Trigger                                                                            | Path                                                    |
+| ---------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------- |
+| `layout-design-system` | Review layout, adjust spacing, density, visual hierarchy, compose dashboards/forms | `frontend/.claude/skills/layout-design-system/SKILL.md` |
+
+### i18n
+
+| Skill            | Trigger                                                                          | Path                                              |
+| ---------------- | -------------------------------------------------------------------------------- | ------------------------------------------------- |
+| `transloco-i18n` | Add translations, create i18n files, configure scope, debug missing translations | `frontend/.claude/skills/transloco-i18n/SKILL.md` |
+
+### Structure & Review
+
+Skills marked with `*` also exist in `backend/.claude/skills/`. When modifying one version, evaluate
+whether the change applies to the other.
+
+| Skill                           | Trigger                                                                                    | Path                                                          |
+| ------------------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
+| `catalyst-project-structure` \* | Navigate the frontend codebase, "where is X", plan where to place new files                | `frontend/.claude/skills/catalyst-project-structure/SKILL.md` |
+| `catalyst-review-module` \*     | Coherence review of a complete frontend module (tree, naming, alignment with other skills) | `frontend/.claude/skills/catalyst-review-module/SKILL.md`     |
+
+---
+
+## Backend (`backend/.claude/skills/`)
+
+NestJS-specific.
+
+### Architecture
+
+| Skill                                  | Trigger                                                                                                                                                                                                                                                                                                                                  | Path                                                                   |
+| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| `catalyst-cross-bounded-context-ports` | Cross-BC dependency (consumer BC needs to read/write data from supplier BC). Canonical Hexagonal pattern: port in consumer side, adapter in supplier side, bridge in composition root. Trigger words: "cross-bc", "consume service from another BC", "imports OtherBcModule". Antipattern detection on `imports: [OtherBcModule]` or wholesale `exports: [...XServices]` in new code | `backend/.claude/skills/catalyst-cross-bounded-context-ports/SKILL.md` |
+
+### Application Layer
+
+| Skill                        | Trigger                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Path                                                         |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| `catalyst-handler-composer`  | Fill in business logic inside CLI-generated handlers in `@app/*/application/*/` (CRUD archetypes + `additionalApis` scaffolds); wire `@EmitEvent` / `@ApplySchema` / `@Format`; decide handler-vs-service split. Step 0 routes CLI-territory through the CLI before any hand edit. ALSO covers hand-written COMPOSITE HANDLERS for protocol-flow endpoints (OAuth token, JWKS, webhooks): the dispatch lives in the handler, NEVER duplicated across transports. Antipattern detection on `if (grantType==='X') ... else if ...` repeated in controller AND resolver | `backend/.claude/skills/catalyst-handler-composer/SKILL.md`  |
+| `catalyst-field-schema`      | Declarative data-access layer: `FieldSchema` + 16 type handlers (incl. `password` bcrypt/mask), the three decorators `@ApplySchema` / `@Format` / `@Sanitize` with decision tree + `payloadIndex`, `Obj.diff` helper, `QueryStatement` shape, 40+ `Operator` enum, `include` patterns, and the documented `formatRecord` security gap with workaround (SPEC-07 upstream)                                                                                       | `backend/.claude/skills/catalyst-field-schema/SKILL.md`      |
+| `catalyst-nestjs-primitives` | Catalog + reuse-first gate for NestJS primitives: the 3 catalyst-authored items (`@Auth` composite, `AuthenticationJwtGuard`, `AuthorizationPermissionsGuard`), upstream decorator catalog (`@Timezone`, `@Auditing`, `@CurrentAccount`, `@ContentLanguage`, `@TenantPolicy`, `@TenantConstraint`), dual REST/GraphQL context via `Api.getRequestFromExecutionContext()`, `dPermissions.all` convention, and last-resort templates                             | `backend/.claude/skills/catalyst-nestjs-primitives/SKILL.md` |
+| `catalyst-backend-testing`   | Starting-point testing conventions for catalyst backend: the decorator-fires-in-TestingModule gotcha (`@ApplySchema` / `@Format` / `@Sanitize` / `@EmitEvent` all run during `handler.main()` in tests), synthesized write/read handler templates anchored on `IamCreateTagHandler` + `IamFindTagByIdHandler`, dual-context guard tests, supertest REST+GraphQL patterns, and the `dPermissions.all` seed utility pattern for `@Auth`-protected endpoint tests | `backend/.claude/skills/catalyst-backend-testing/SKILL.md`   |
+
+### Structure & Review
+
+Skills marked with `*` also exist in `frontend/.claude/skills/`. When modifying one version,
+evaluate whether the change applies to the other.
+
+| Skill                           | Trigger                                                                                   | Path                                                         |
+| ------------------------------- | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| `catalyst-project-structure` \* | Navigate the backend codebase, "where is X", plan where to place new files. Now includes the **Hand-written protocol-flow endpoints** section: dedicated `<flow>.module.ts` + `controllers/` + `resolvers/` + `graphql/` subdirs; the generated BC module IMPORTS the flow module instead of registering its hand-written code | `backend/.claude/skills/catalyst-project-structure/SKILL.md` |
+| `catalyst-review-module` \*     | Coherence review of a complete backend module (tree, naming, alignment with other skills) | `backend/.claude/skills/catalyst-review-module/SKILL.md`     |