mustard-claude 3.1.26 → 3.1.27

package/README.md

@@ -29,7 +29,7 @@ Mustard sets up a `.claude/` folder that turns Claude Code into a structured dev
 - **16 pipeline commands** — feature, bugfix, approve, complete, resume, scan, scan-format, git, maint, task, knowledge, skill, status, stats, metrics, review, plus the agent-prompt template
 - **23 enforcement hooks** — bash safety, bash native redirect, file guard, registry enforcement, guard verify, auto-format, pre-compact, session cleanup, subagent tracker, RTK rewrite, session memory, review gate, metrics tracker, MCP budget, session knowledge, context budget, spec hygiene, output budget, tool-use counter, model routing gate, debug-loop guard, user-prompt hint, session-knowledge incremental
 - **6 bundled skills** — design-craft, react-best-practices, senior-architect, skill-creator, commit-workflow, pipeline-execution
-- **15 utility scripts** — subproject detection, entity registry sync, statusline, memory persist/write, diff context, knowledge update, metrics collect/report, security scan, pipeline verification, analyze validation, recipe matcher, skill generator
+- **15 utility scripts** — subproject detection, entity registry sync, skill validation, statusline, memory persist/write, diff context, knowledge update, metrics collect/report, security scan, pipeline verification, analyze validation, recipe matcher, RTK gain import
 - **Token economy** — auto-installs [RTK (Rust Token Killer)](https://github.com/rtk-ai/rtk) to reduce CLI-output tokens by 60–90%
 - **Hook profiles & env overrides** — minimal/standard/strict profiles via `_lib/hook-env.js`; disable individual hooks with `MUSTARD_DISABLED_HOOKS`
 - **Cursor IDE adapter** (experimental) — `mustard init --cursor` installs a Cursor-compatible hook adapter
@@ -287,7 +287,8 @@ mustard review --ci --pr 42
 │   └── user-prompt-hint.js            #   Surfaces contextual hints on prompt input
 ├── scripts/                           # Utility scripts (15)
 │   ├── sync-detect.js                 #   Detects subprojects + roles (SHA-256 incremental)
-│   ├── sync-registry.js               #   Generates entity-registry.json
+│   ├── sync-registry.js               #   Generates entity-registry.json (_patterns.discovered[])
+│   ├── skill-validate.js              #   Validates SKILL.md frontmatter across subprojects
 │   ├── statusline.js                  #   Claude Code statusline
 │   ├── memory-persist.js              #   Persists decisions/lessons across sessions
 │   ├── memory-write.js                #   Writes agent memory entries between waves
@@ -295,11 +296,11 @@ mustard review --ci --pr 42
 │   ├── knowledge-update.js            #   Updates project knowledge base
 │   ├── metrics-collect.js             #   Collects pipeline metrics
 │   ├── metrics-report.js              #   Renders enforcement metrics report
+│   ├── rtk-gain-import.js             #   Imports RTK token-savings data for metrics
 │   ├── security-scan.js               #   Scans for secrets / security misconfigs
 │   ├── verify-pipeline.js             #   Runs build/test verification
 │   ├── analyze-validation.js          #   Validates ANALYZE phase output
 │   ├── recipe-match.js                #   Structured recipe matcher (entity + operation)
-│   ├── skill-generator.js             #   Generates subproject pattern skills
 │   └── _metrics-write.js              #   Internal metrics writer (used by hooks)
 ├── memory/                            # Persistent memory (auto-created)
 │   ├── decisions.json                 #   Decisions across pipelines

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustard-claude",
-  "version": "3.1.26",
+  "version": "3.1.27",
   "description": "Framework-agnostic CLI for Claude Code project setup",
   "type": "module",
   "bin": {

package/templates/CLAUDE.md

@@ -47,7 +47,7 @@ node scripts/sync-detect.js --no-cache
 node scripts/sync-registry.js
 node scripts/sync-registry.js --force
 
-# Skill validation (runs automatically at end of skill-generator.js; also callable standalone)
+# Skill validation (invoked by /scan §4.7; also callable standalone)
 node scripts/skill-validate.js
 node scripts/skill-validate.js --json
 ```

package/templates/commands/mustard/scan/SKILL.md

@@ -12,7 +12,7 @@
   - Ignora o incremental skip do Step 1/C: **todos** os subprojetos são reprocessados, independente de hash match ou `gitDirty`.
   - Bypassa o fast-path de §2.6 (Bootstrap): sempre regenera `.claude/CLAUDE.md` e afins.
   - Repassa "FORCE MODE" aos Task agents do Step 3 (eles apagam `{subproject}/.claude/skills/*/` com header `mustard:generated` antes de regerar).
-  - Roda sempre os dois comandos de §4.7 (`sync-registry.js --force` + `skill-generator.js --force`), mesmo com registry já v4.0.
+  - Roda `sync-registry.js --force` (§4.7) sempre — mesmo com registry já v4.0.
   - Skills sem o header `mustard:generated` (user-authored) são **preservadas**.
 
 ## Execution Model
@@ -326,7 +326,7 @@ See `scan-format.md` §10 for decomposition rules, SKILL.md format, and descript
 
 **Key rules:**
 - One conceptual pattern = one skill (not one file = one skill)
-- Skill name: `{subproject-short}-{pattern-name}` (e.g., `api-endpoint-wiring`, `app-mvvm-feature`)
+- Skill name: `{subproject-short}-{pattern-name}` — pattern-name is a kebab-case concept the codebase itself uses (derived from its folders / file suffixes / domain vocabulary), never a library brand or imported taxonomy
 - Description must be "pushy" — include casual trigger phrases (see scan-format.md §10)
 - Extract real code examples into `references/examples.md`
 - Max 500 lines per SKILL.md body (ideally <200)
@@ -342,32 +342,15 @@ See `scan-format.md` §10 for decomposition rules, SKILL.md format, and descript
 Skills are generated ONLY in `{subproject}/.claude/skills/{skill-name}/` (NOT in root `.claude/skills/`).
 Mark all with `<!-- mustard:generated -->`. Overwrite on next scan.
 
-### 4.7. Generate Pattern Skills from Registry (OODA: Observe → Act)
+### 4.7. Refresh Registry
 
-After agent-generated skills (4.6), run the registry-based skill generator to create structural pattern skills from `_patterns`:
-
-> With `--force`, **always** run both commands — even if `entity-registry.json` already exists at v4.0.
+Run the registry scanner so the agent-generated skills of step 3 have the latest `_patterns.discovered[]` clusters available for future scans:
 
 ```bash
 node .claude/scripts/sync-registry.js --force
-node .claude/scripts/skill-generator.js --force
 ```
 
-This generates skills that the agents in Step 3 may have missed — particularly:
-- `{role}-entity-creation` — entity folder, base class, interfaces, namespace
-- `{role}-enum-placement` — enum folder, decorators, NEVER inline in entities
-- `{role}-route-conventions` — route naming, auth pattern, CRUD standard
-- `{role}-service-pattern` — interface-first, base interface, DI
-- `{role}-repository-pattern` — base class, interface, DI
-- `{role}-dto-conventions` — folder, naming, validation pattern
-- `{role}-module-registration` — DI registration, route wiring
-
-These skills are derived from **detected patterns** (not hardcoded). They complement agent-generated skills by covering structural conventions that agents may not explicitly document.
-
-**Skip conditions:**
-- `entity-registry.json` version < 4.0 → skip (registry not populated)
-- `skill-generator.js` not present → skip
-- Pattern skill already exists and was NOT generated by mustard → skip (user-edited, unless `--force` — but `skill-generator.js` already preserves user-authored skills by checking the `mustard:generated` header)
+Skill generation itself is **entirely the responsibility of the Step 3 agents** (see `scan-format.md` §10). There is no separate mechanical generator — the agent reads `_patterns[*].discovered[]` and emits cluster skills directly.
 
 ### 4. Update CLAUDE.md files
 

package/templates/commands/mustard/scan-format/SKILL.md

@@ -183,27 +183,42 @@ Follow the [skill-creator](https://github.com/anthropics/skills) methodology for
 
 ### Decomposition Rules
 
-Each detected pattern becomes its own skill. Group by conceptual unit, not by file:
-
-| Pattern type | Skill name format | Example |
-|-------------|------------------|---------|
-| Module/endpoint registration | `{sub}-module-registration` | `api-module-registration` |
-| Endpoint wiring | `{sub}-endpoint-wiring` | `api-endpoint-wiring` |
-| Repository pattern | `{sub}-repository-pattern` | `api-repository-pattern` |
-| Service layer | `{sub}-service-base` | `api-service-base` |
-| DTO + validation | `{sub}-dto-validation` | `api-dto-validation` |
-| Mapper config | `{sub}-mapster-config` | `api-mapster-config` |
-| GraphQL resolver | `{sub}-graphql-resolver` | `api-graphql-resolver` |
-| Entity + config | `{sub}-entity-config` | `api-entity-config` |
-| Background job | `{sub}-hangfire-job` | `api-hangfire-job` |
-| MVVM feature | `{sub}-mvvm-feature` | `app-mvvm-feature` |
-| State management | `{sub}-riverpod-state` | `app-riverpod-state` |
-| Network/repository | `{sub}-dio-repository` | `app-dio-repository` |
-| Routing | `{sub}-go-router` | `app-go-router` |
-| Section component | `{sub}-section-component` | `landing-section-component` |
-| i18n pattern | `{sub}-i18n-pattern` | `landing-i18n-pattern` |
-
-Adapt to what the codebase actually has — this table is guidance, not rigid.
+Each detected pattern becomes its own skill. Group by **conceptual unit**, not by file. The agent derives both the skill name and its scope from what the codebase actually shows — no fixed list of technologies, no predetermined taxonomy.
+
+**Naming**: `{subproject-short}-{kebab-case-concept}` — the concept is whatever the codebase itself calls the thing. If the project has a folder called `Resolvers/`, the skill is `{sub}-resolver-pattern`. If it has `composables/`, it's `{sub}-composable-pattern`. If it has `Handlers/`, it's `{sub}-handler-pattern`. Never import vocabulary the codebase does not use.
+
+**Scope**: one skill per reusable convention the agent would hand to a future agent implementing "add one more like these". If the pattern is a one-off file, it is not a convention — skip it.
+
+**Anti-patterns to avoid**:
+- Emitting a skill for every file type (`.ts`, `.css`, `.json` → three skills = noise)
+- Emitting a skill for generic cross-cutting concerns (logging, error handling) unless the codebase has a distinctive, repeated shape for them
+- Naming a skill after a library the codebase uses but whose convention is entirely the library's default (e.g. "using React hooks as documented" is not a codebase convention)
+
+### Cluster Skills from the Registry (mandatory)
+
+After generating the conceptual skills above, **also** read `.claude/entity-registry.json` and iterate `_patterns[{stackId}].discovered[]` for each detected stack. Each cluster entry looks like:
+
+```json
+{
+  "suffix": "Service",
+  "fileCount": 7,
+  "folders": ["src/Services", "src/Modules/Auth/Services"],
+  "samples": ["src/Services/UserService.cs", "..."],
+  "commonBaseClass": "BaseService",
+  "commonInterfaces": ["IService"]
+}
+```
+
+For each cluster that represents a **reusable convention** (skip one-offs, test-only files, or trivial groupings), emit a skill named `{sub}-{suffix-slug}-pattern` (e.g. `backend-service-pattern`, `frontend-component-pattern`). SKILL.md body:
+
+- `## Pattern` — enumerate `suffix`, `fileCount`, `folderPattern`, `commonBaseClass`, `commonInterfaces` as bullets (fields that exist in the cluster — do not invent).
+- `## Rules` — DO/DON'T derived from the cluster (naming, folder placement, base class usage).
+- `## Samples in this project` — bullet list of the `samples` file paths.
+- `## References` — pointer to `references/examples.md`.
+
+**Agent judgment filter**: do NOT blindly emit one skill per cluster. If a cluster has fewer than ~3 files OR the suffix is generic noise (e.g. `Test`, `Mock`, `Spec`), skip it. The goal is reusable conventions, not coverage theater.
+
+`_patterns.folderFrequency` provides a stopword source for distinctive-keyword extraction: segments appearing in ≥60% of all folders are structural noise and should be ignored when describing the cluster.
 
 ### Skill Structure
 
@@ -216,35 +231,56 @@ Adapt to what the codebase actually has — this table is guidance, not rigid.
 
 ### SKILL.md Format (skill-creator standard)
 
+**CRITICAL — NO CODE IN SKILL.md.** The SKILL.md body describes the pattern in prose + bullet lists + file references. **Never** embed code blocks, language-specific stubs, or synthesized examples (no fake `class Order { ... }`, no TypeScript snippet, no SQL, nothing). All concrete code lives in `references/examples.md`, extracted from real source files.
+
 ```yaml
 ---
 name: {skill-name}
 description: "{What it does}. {When to use it — be specific and 'pushy'}.
   Use when {trigger phrase 1}, {trigger phrase 2}, or {trigger phrase 3}.
   Even if the user just says '{casual phrase}'."
+source: scan
 ---
 <!-- mustard:generated at:{ISO} role:{role} -->
 
 # {Skill Title}
 
-{1-2 sentence summary of the pattern.}
+> Pattern detected in this project.
 
-## Pattern
+## Convention
 
-{Concise pattern description with file path conventions.}
-{Key rules and constraints — explain WHY, not just WHAT.}
+- Folder: `{detected folder}`
+- {other fields present in the pattern — enumerate dynamically, do not assume}
+- Naming: `{detected naming convention}`
 
-## Example
+## Real examples in this codebase
 
-{One compact code example (5-10 lines max) showing the happy path.}
-Ref: `{path/to/real/file.ext}`
+- `{EntityName}` — `{path/to/real/file.ext}`
+- `{OtherEntity}` — `{path/to/other/file.ext}`
 
 ## References
 
-For full code examples with variants:
-→ Read `references/examples.md`
+See `references/examples.md` for extracted code.
+```
+
+**Important:** The `## Convention` section lists detected fields from the registry pattern directly (folder, base class, naming, interfaces, etc.). The `## Real examples` section lists actual file paths from the registry. Concrete code — if any is needed at all — belongs only in `references/examples.md`, extracted from real source files (never handwritten).
+
+### references/examples.md Format
+
+```markdown
+<!-- mustard:generated at:{ISO} -->
+
+# {Pattern} — real examples from this codebase
+
+## {EntityName}
+Source: `{path/to/real/file.ext}`
+\`\`\`{lang-from-extension}
+{actual file content or excerpt — ≤80 lines full, or first class declaration ±20 lines}
+\`\`\`
 ```
 
+File extension maps to fence language: `.ts` → `typescript`, `.cs` → `csharp`, `.py` → `python`, `.dart` → `dart`, etc. Unknown extension: no language tag. If the file does not exist (stale registry), skip that entry silently.
+
 ### Description Writing Guidelines (from skill-creator)
 
 Descriptions are the PRIMARY trigger mechanism — Claude uses them to decide which skills to load.

package/templates/commands/mustard/skill/SKILL.md

@@ -148,6 +148,6 @@ Update the skill-creator from the anthropics/skills repo.
 - ALWAYS use skill-creator for `/skill create` — don't write skills from scratch
 - `/skill optimize` and `/skill eval` require Python 3 and `claude` CLI
 - `source:` field semantics (TERRITORIAL):
-  - `skill-generator.js` writes `source: scan` ONLY — never touches `source: manual`.
+  - `/scan` agents (§4.6, §10) write `source: scan` ONLY — never touch `source: manual`.
   - `/skill install`, `/skill create`, skill-creator write `source: manual` ONLY — never touch `source: scan`.
   - Missing `source:` → treat as `manual` (conservative, protects user edits).

package/templates/commands/mustard/templates/agent-prompt/SKILL.md

@@ -72,9 +72,9 @@ Based on task analysis, list the most relevant skill names:
 - Architecture decisions → `senior-architect`
 - Complex patterns → relevant advanced pattern skills
 
-Examples (replace `{sub}` with actual subproject short name):
-- Backend endpoint → `{sub}-endpoint-wiring, {sub}-module-registration`
-- Mobile screen → `{sub}-mvvm-feature, {sub}-riverpod-state, design-craft`
-- Frontend section → `{sub}-section-component, design-craft, react-best-practices`
+Examples (replace `{sub}` with actual subproject short name; skill names below are placeholders — pick whatever skills the subproject's `.claude/skills/` actually defines):
+- Backend endpoint → `{sub}-{endpoint-skill}, {sub}-{module-skill}`
+- Mobile screen → `{sub}-{screen-skill}, {sub}-{state-skill}, design-craft`
+- Frontend section → `{sub}-{section-skill}, design-craft, react-best-practices`
 
 ULTRATHINK

package/templates/hooks/__tests__/skill-generator.snapshot.test.js

@@ -1,230 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert');
-const { execSync } = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const ROOT = path.resolve(__dirname, '..', '..', '..');
-const SCRIPT = path.join(ROOT, 'templates', 'scripts', 'skill-generator.js');
-
-test('skill-generator: --dry-run output is stable across runs', () => {
-  const opts = { encoding: 'utf-8', cwd: ROOT };
-  const out1 = execSync(`node "${SCRIPT}" --dry-run`, opts);
-  const out2 = execSync(`node "${SCRIPT}" --dry-run`, opts);
-  assert.strictEqual(out1, out2, 'dry-run output should be deterministic');
-});
-
-test('skill-generator: --check flag passes (JS syntax valid)', () => {
-  const out = execSync(`node --check "${SCRIPT}"`, { encoding: 'utf-8', cwd: ROOT });
-  // node --check exits 0 on success, no assertion needed beyond no-throw
-  assert.ok(true, 'syntax check passed');
-});
-
-test('skill-generator: _skill-meta.json is valid JSON with required keys', () => {
-  const metaPath = path.join(ROOT, 'templates', 'scripts', '_skill-meta.json');
-  const meta = JSON.parse(require('fs').readFileSync(metaPath, 'utf-8'));
-  assert.ok(meta.stacks && typeof meta.stacks === 'object', 'must have stacks');
-  assert.ok(meta.roles && typeof meta.roles === 'object', 'must have roles');
-  assert.ok(meta.stacks.dotnet, 'stacks.dotnet must exist');
-  assert.ok(meta.stacks.typescript, 'stacks.typescript must exist');
-  assert.strictEqual(meta.stacks.dotnet.lang, 'csharp');
-});
-
-test('skill-generator: validateSkill catches missing description', () => {
-  // skill-generator exports validateSkill via module.exports when required (not run as main)
-  const { validateSkill } = require('../../scripts/skill-generator.js');
-  assert.ok(typeof validateSkill === 'function', 'validateSkill must be exported');
-
-  // Test: missing frontmatter
-  let r = validateSkill('no frontmatter here');
-  assert.strictEqual(r.ok, false, 'should fail without frontmatter');
-  assert.ok(r.errors.some(e => e.includes('frontmatter')), 'error should mention frontmatter');
-
-  // Test: missing description
-  r = validateSkill('---\nname: foo-bar\nsource: scan\n---\n<!-- mustard:generated -->\nhi');
-  assert.strictEqual(r.ok, false, 'should fail without description');
-  assert.ok(r.errors.some(e => e.includes('description')), 'error should mention description');
-
-  // Test: missing source
-  r = validateSkill('---\nname: foo-bar\ndescription: "Use when creating a new entity, add model, create table, even if the user says new thing. This is long enough."\n---\n<!-- mustard:generated -->\nhi');
-  assert.strictEqual(r.ok, false, 'should fail without source');
-  assert.ok(r.errors.some(e => e.includes('source')), 'error should mention source');
-
-  // Test: valid
-  r = validateSkill('---\nname: foo-bar\ndescription: "Use when creating a new entity, add model, create table, even if the user says new thing. This is long enough to pass."\nsource: scan\n---\n<!-- mustard:generated -->\nhi');
-  assert.strictEqual(r.ok, true, 'valid skill should pass');
-});
-
-test('skill-generator: all skill .tmpl files have source: scan in frontmatter', () => {
-  const fs = require('fs');
-  const tplDir = path.join(ROOT, 'templates', 'skill-templates');
-  const files = fs.readdirSync(tplDir).filter(f => f.endsWith('.skill.md.tmpl'));
-  assert.ok(files.length > 0, 'should have at least one skill template');
-  for (const file of files) {
-    const content = fs.readFileSync(path.join(tplDir, file), 'utf-8');
-    assert.ok(content.includes('source: scan'), `${file} must contain "source: scan" in frontmatter`);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Cluster discovery tests
-// ---------------------------------------------------------------------------
-
-test('cluster-discovery: discovers suffix-cluster from synthetic temp dir', () => {
-  const fs = require('fs');
-  const os = require('os');
-  const { discoverClusters } = require('../../scripts/registry/cluster-discovery.js');
-
-  // Create a temporary directory structure with 5+ files sharing suffix "Handler"
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mustard-test-'));
-  const subDir = path.join(tmpDir, 'Commands');
-  fs.mkdirSync(subDir, { recursive: true });
-
-  const files = [
-    'CreateUserHandler.cs',
-    'UpdateUserHandler.cs',
-    'DeleteUserHandler.cs',
-    'CreateContractHandler.cs',
-    'UpdateContractHandler.cs',
-    'CreateInvoiceHandler.cs',
-  ];
-  for (const f of files) {
-    fs.writeFileSync(path.join(subDir, f), `public class ${f.replace('.cs', '')} { }`);
-  }
-
-  try {
-    const clusters = discoverClusters(tmpDir, 'dotnet');
-    assert.ok(Array.isArray(clusters), 'should return array');
-    assert.ok(clusters.length >= 1, 'should find at least one cluster');
-
-    const handlerCluster = clusters.find(c => c.suffix === 'Handler');
-    assert.ok(handlerCluster, 'should detect "Handler" suffix cluster');
-    assert.ok(handlerCluster.fileCount >= 6, `expected fileCount >= 6, got ${handlerCluster.fileCount}`);
-    assert.ok(
-      handlerCluster.kind === 'folder-cluster' || handlerCluster.kind === 'suffix-cluster',
-      `expected folder-cluster or suffix-cluster, got ${handlerCluster.kind}`
-    );
-  } finally {
-    // Cleanup
-    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
-  }
-});
-
-test('cluster-discovery: no hardcoded tech names in cluster-discovery.js source', () => {
-  const fs = require('fs');
-  const src = fs.readFileSync(
-    path.join(ROOT, 'templates', 'scripts', 'registry', 'cluster-discovery.js'),
-    'utf-8'
-  );
-  // These technology names must NOT appear in non-comment source lines of the discovery code.
-  // We strip comment lines before checking so JSDoc examples don't trigger false positives.
-  const forbidden = ['graphql', 'GraphQL', 'cqrs', 'CQRS', 'mediator', 'Mediator'];
-  const codeLines = src.split('\n').filter(line => {
-    const trimmed = line.trim();
-    return !trimmed.startsWith('//') && !trimmed.startsWith('*') && trimmed !== '';
-  });
-  const codeOnly = codeLines.join('\n');
-  for (const word of forbidden) {
-    assert.ok(
-      !codeOnly.includes(word),
-      `cluster-discovery.js must not contain hardcoded tech term "${word}" in non-comment code`
-    );
-  }
-});
-
-test('genClusterSkill: produces valid SKILL.md for Handler cluster', () => {
-  const { genClusterSkill, validateSkill } = require('../../scripts/skill-generator.js');
-
-  const cluster = {
-    kind: 'suffix-cluster',
-    suffix: 'Handler',
-    ext: '.cs',
-    fileCount: 7,
-    folders: ['Commands/Create', 'Commands/Update', 'Commands/Delete'],
-    folderPattern: '**/Commands/',
-    samples: ['CreateUserHandler.cs', 'UpdateContractHandler.cs', 'DeleteInvoiceHandler.cs'],
-    label: 'Handler',
-  };
-
-  const result = genClusterSkill('backend', 'dotnet', cluster, 'api');
-  assert.ok(result !== null, 'genClusterSkill should return a result');
-  assert.ok(result.slug === 'handler', `slug should be "handler", got "${result.slug}"`);
-
-  const validation = validateSkill(result.skillMd);
-  assert.ok(validation.ok, `generated skill should be valid. Errors: ${validation.errors.join(', ')}`);
-
-  // Frontmatter name must start with skill prefix
-  assert.ok(result.skillMd.includes('backend-handler-pattern'), 'name should be backend-handler-pattern');
-
-  // Must NOT contain forbidden tech names as string literals in the output
-  const forbidden = ['graphql', 'GraphQL', 'cqrs', 'mediator'];
-  for (const word of forbidden) {
-    assert.ok(!result.skillMd.includes(word), `output must not contain "${word}"`);
-  }
-});
-
-test('cleanupOrphanSkills: removes source:scan folders not in expected set', () => {
-  const { cleanupOrphanSkills } = require('../../scripts/skill-generator.js');
-
-  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mustard-cleanup-'));
-  const skillsDir = path.join(tmpRoot, '.claude', 'skills');
-
-  const mkSkill = (folder, frontmatter) => {
-    const dir = path.join(skillsDir, folder);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, 'SKILL.md'), `---\n${frontmatter}\n---\n# skill`);
-  };
-
-  // Expected skills (current run will write these)
-  mkSkill('backend-entity-creation', 'name: backend-entity-creation\ndescription: x\nsource: scan');
-  mkSkill('backend-service-pattern', 'name: backend-service-pattern\ndescription: x\nsource: scan');
-
-  // Orphan: was generated previously but pattern no longer exists
-  mkSkill('backend-queryresolver-pattern', 'name: backend-queryresolver-pattern\ndescription: x\nsource: scan');
-
-  // Manual skill — MUST NOT be touched (source: manual)
-  mkSkill('backend-custom-helper', 'name: backend-custom-helper\ndescription: x\nsource: manual');
-
-  // Unrelated sub — MUST NOT be touched (not in processed subs)
-  mkSkill('frontend-entity-creation', 'name: frontend-entity-creation\ndescription: x\nsource: scan');
-
-  const expected = new Set(['backend-entity-creation', 'backend-service-pattern']);
-  const log = [];
-  const removed = cleanupOrphanSkills(skillsDir, expected, ['backend'], log);
-
-  try {
-    assert.strictEqual(removed, 1, 'should remove exactly 1 orphan');
-    assert.ok(!fs.existsSync(path.join(skillsDir, 'backend-queryresolver-pattern')), 'orphan removed');
-    assert.ok(fs.existsSync(path.join(skillsDir, 'backend-entity-creation')), 'expected preserved');
-    assert.ok(fs.existsSync(path.join(skillsDir, 'backend-custom-helper')), 'source:manual preserved');
-    assert.ok(fs.existsSync(path.join(skillsDir, 'frontend-entity-creation')), 'other sub preserved');
-  } finally {
-    try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
-  }
-});
-
-test('cluster-discovery: min suffix length filters short suffixes', () => {
-  const fs = require('fs');
-  const os = require('os');
-  const { discoverClusters } = require('../../scripts/registry/cluster-discovery.js');
-
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mustard-test-short-'));
-  const subDir = path.join(tmpDir, 'Models');
-  fs.mkdirSync(subDir, { recursive: true });
-
-  // Files ending in short suffix "es" should NOT trigger a cluster
-  const files = ['Bankes.cs', 'Foxes.cs', 'Boxes.cs', 'Taxes.cs', 'Mixes.cs', 'Fixes.cs'];
-  for (const f of files) {
-    fs.writeFileSync(path.join(subDir, f), `public class ${f.replace('.cs', '')} { }`);
-  }
-
-  try {
-    const clusters = discoverClusters(tmpDir, 'dotnet');
-    const shortSuffix = clusters.find(c => c.suffix === 'es' || c.suffix.length < 6);
-    assert.ok(!shortSuffix, 'should NOT detect short suffix clusters (< 6 chars)');
-  } finally {
-    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
-  }
-});

package/templates/scripts/_fence-languages.json

@@ -1,57 +0,0 @@
-{
-  ".cs":    "csharp",
-  ".ts":    "typescript",
-  ".tsx":   "typescript",
-  ".js":    "javascript",
-  ".jsx":   "javascript",
-  ".mjs":   "javascript",
-  ".dart":  "dart",
-  ".py":    "python",
-  ".java":  "java",
-  ".go":    "go",
-  ".rs":    "rust",
-  ".rb":    "ruby",
-  ".php":   "php",
-  ".kt":    "kotlin",
-  ".kts":   "kotlin",
-  ".ex":    "elixir",
-  ".exs":   "elixir",
-  ".swift": "swift",
-  ".elm":   "elm",
-  ".zig":   "zig",
-  ".cr":    "crystal",
-  ".gleam": "gleam",
-  ".erl":   "erlang",
-  ".hrl":   "erlang",
-  ".scala": "scala",
-  ".clj":   "clojure",
-  ".cljs":  "clojure",
-  ".hs":    "haskell",
-  ".ml":    "ocaml",
-  ".mli":   "ocaml",
-  ".lua":   "lua",
-  ".nim":   "nim",
-  ".v":     "v",
-  ".rkt":   "racket",
-  ".jl":    "julia",
-  ".r":     "r",
-  ".R":     "r",
-  ".sh":    "bash",
-  ".bash":  "bash",
-  ".zsh":   "bash",
-  ".ps1":   "powershell",
-  ".sql":   "sql",
-  ".proto": "protobuf",
-  ".tf":    "terraform",
-  ".yaml":  "yaml",
-  ".yml":   "yaml",
-  ".toml":  "toml",
-  ".json":  "json",
-  ".xml":   "xml",
-  ".html":  "html",
-  ".css":   "css",
-  ".scss":  "scss",
-  ".sass":  "sass",
-  ".vue":   "vue",
-  ".svelte":"svelte"
-}

package/templates/scripts/_skill-meta.json

@@ -1,10 +0,0 @@
-{
-  "roles": {
-    "api":      "backend",
-    "ui":       "frontend",
-    "database": "database",
-    "mobile":   "mobile",
-    "library":  "backend",
-    "general":  "general"
-  }
-}