plankit-cli 1.3.1 → 1.4.0

package/README.md

@@ -58,7 +58,7 @@ plankit review my-feature
 
 | Command | Action |
 |---|---|
-| `plankit init [--agent <name>]` | Create PlanKit config, artifact folders, spec, and the **selected agent's** folders/commands. Prompts for the agent when none is specified. |
+| `plankit init [--agent <name>] [--framework <name>]` | Create PlanKit config, artifact folders, spec, and the **selected agent's** folders/commands. Prompts for the agent and framework suite(s) when run interactively. |
 | `plankit plan <feature> [requirements]` | Create `artifacts/current/<feature>/` with README, phase specs, outputs folder, and state metadata. |
 | `plankit clarify <feature> [phase]` | Create a clarification artifact for requirements and design decisions. |
 | `plankit implement <feature> <phase>` | Validate phase context (spec + prior outputs) and prepare `outputs/phase-N-output.md`. |
@@ -77,6 +77,8 @@ plankit review my-feature
 | `--force` | Overwrite generated files where safe. |
 | `--dry-run` | Show intended actions without writing anything. |
 | `--agent <name>` | Select your coding agent during `init` (`opencode`, `gemini`, `codex`, `cursor`; default `opencode`). |
+| `--framework <name>` | Select framework command suite during `init` (`angular`, `vue`, `dotnet`, `none`, `all`; default `none`). |
+| `--frameworks <list>` | Comma-separated list of framework command suites (e.g. `vue,dotnet`). |
 
 ### Plan options
 
@@ -162,7 +164,55 @@ plankit init --agent cursor
 
 ---
 
-## Angular command suite
+## Framework command suites
+
+During `plankit init`, PlanKit prompts you to choose optional framework-specific command suites (or pass `--framework <name>` / `--frameworks <names>`):
+- **None**: Installs only the core PlanKit feature planning workflow.
+- **Angular**: Installs 17 Angular engineering workflows.
+- **Vue**: Installs 15 Vue modernization and architectural standardization workflows.
+- **.NET**: Installs 10 .NET clean architecture and API engineering workflows.
+- **All**: Installs all supported framework suites.
+
+### Vue modernization suite (`--framework vue`)
+
+Designed for legacy and mixed Vue codebases (JavaScript/TypeScript, Options API, Composition API, `<script setup>`, Vuex/Pinia) following the PlanKit Vue Modernization Specification:
+
+| Command | Purpose |
+|---|---|
+| `vue-health` | Audit Vue codebase health, tech debt score, Options vs Composition ratio, and modernization risks. |
+| `vue-pattern-map` | Map architectural patterns across state, data fetching, styling, and components. |
+| `vue-target-architecture` | Define or inspect target architectural conventions (Vue 3, `<script setup>`, TS, Pinia). |
+| `vue-legacy-map` | Catalog legacy Vue files, mixins, filters, Options API components, and hotspots. |
+| `vue-standardize` | Refactor a component or composable to conform to the established target architecture. |
+| `vue-migration-plan` | Generate an incremental, phased migration plan for a legacy feature slice. |
+| `js-to-ts` | Convert JavaScript Vue SFCs and utility modules to TypeScript with typed props/emits. |
+| `vue-style-audit` | Audit styling patterns, global vs scoped CSS/SCSS, deep selectors, and hardcoded values. |
+| `design-token-discover` | Discover repeated color literals, typography, spacing, and shadows into token candidates. |
+| `design-token-migrate` | Migrate hardcoded styles in Vue components to standardized design tokens. |
+| `state-strategy-audit` | Audit Vuex vs Pinia vs composables; detect state duplication and reactivity leaks. |
+| `reactivity-audit` | Audit reactivity anti-patterns (destructuring props without `toRefs`, watcher leaks). |
+| `component-pattern-audit` | Audit SFC component design, god components, prop drilling, and emits declarations. |
+| `vue-modernize-slice` | Orchestrate an end-to-end modernization of a Vue feature slice with validation. |
+| `vue-guardrails` | Configure ESLint rules and TypeScript strict settings to prevent legacy regressions. |
+
+### .NET clean architecture suite (`--framework dotnet`)
+
+Designed for ASP.NET Core and .NET solutions following Clean Architecture and Vertical Slice patterns:
+
+| Command | Purpose |
+|---|---|
+| `dotnet-health` | Audit solution health: SDK versions, NuGet packages, vulnerabilities, and compiler warnings. |
+| `dotnet-architecture-audit` | Audit layer dependencies (Domain, Application, Infrastructure, API) and circular references. |
+| `dotnet-feature` | Build an end-to-end vertical slice feature (Command/Query, MediatR, FluentValidation, Endpoint). |
+| `dotnet-endpoint-from-model` | Generate ASP.NET Core Minimal API or Controller endpoints with typed results and error handling. |
+| `dotnet-migrate-minimal-api` | Migrate traditional controllers to modern Minimal API route groups. |
+| `dotnet-ef-migration` | Safe Entity Framework Core migration lifecycle: entity check, migration, SQL preview, rollback. |
+| `dotnet-extract-service` | Refactor fat services into isolated CQRS handlers or domain services. |
+| `dotnet-generate-tests` | Generate xUnit/NUnit tests with FluentAssertions and WebApplicationFactory integration tests. |
+| `dotnet-clean-guardrails` | Generate NetArchTest architectural unit tests and EditorConfig rules to guard layer boundaries. |
+| `dotnet-modernize` | Upgrade legacy C# syntax to modern C# 12+ / .NET 8+ patterns (primary constructors, collection expressions). |
+
+### Angular command suite (`--framework angular`)
 
 Alongside the phase workflow, `init` installs a per-agent Angular command library that gives your AI assistant **16 deterministic Angular engineering workflows**, driven by repository discovery rather than generic prompts:
 
@@ -187,7 +237,7 @@ Alongside the phase workflow, `init` installs a per-agent Angular command librar
 
 Plus a shared `angular-project-discovery` reference that every command leans on (Angular version, standalone vs NgModule, Signals/RxJS, state management, forms strategy, UI library, styling, testing, conventions, architecture).
 
-Only your **selected agent's** folder/commands are copied. To customize the Angular command templates in your own `templatesDir`, mirror the `templates/angular-commands/` and `templates/angular-skills/` folder layout from the package.
+Only your **selected agent's** folder/commands are copied. To customize the command templates in your own `templatesDir`, mirror the `templates/<framework>-commands/` and `templates/<framework>-skills/` folder layout from the package.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plankit-cli",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "PlanKit Command Suite CLI for AI Coding Assistants (Antigravity, OpenCode, Codex, Cursor)",
   "main": "src/cli.js",
   "bin": {

package/src/agents.js

@@ -33,7 +33,7 @@ export const AGENTS = {
       { template: 'opencode/plankit-implement.md', dest: ['.opencode', 'commands', 'plankit-implement.md'] },
       { template: 'opencode/plankit-review.md', dest: ['.opencode', 'commands', 'plankit-review.md'] }
     ],
-    commandBundles: ['opencode-angular'],
+    commandBundles: [],
     globalSkillEntries: null
   },
   gemini: {
@@ -44,7 +44,7 @@ export const AGENTS = {
     bindings: [
       { template: 'gemini-instructions.md', dest: ['.gemini', 'instructions.md'] }
     ],
-    commandBundles: ['gemini-angular'],
+    commandBundles: [],
     globalSkillEntries: GEMINI_SKILL_ENTRIES
   },
   codex: {
@@ -55,7 +55,7 @@ export const AGENTS = {
     bindings: [
       { template: 'AGENTS.md', dest: ['AGENTS.md'] }
     ],
-    commandBundles: ['codex-angular'],
+    commandBundles: [],
     globalSkillEntries: null
   },
   cursor: {
@@ -66,11 +66,15 @@ export const AGENTS = {
     bindings: [
       { template: 'cursorrules', dest: ['.cursorrules'] }
     ],
-    commandBundles: ['cursor-angular'],
+    commandBundles: [],
     globalSkillEntries: null
   }
 };
 
+export function resolveAgentBundles(agentId, frameworks = []) {
+  return (frameworks || []).map((fw) => `${agentId}-${fw}`);
+}
+
 export function listAgents() {
   return AGENT_ORDER.map((id) => AGENTS[id]);
 }

package/src/cli.js

@@ -15,8 +15,14 @@ import {
   writeManagedFile
 } from './config.js';
 import { renderList, renderTemplate, packageRoot } from './templates.js';
-import { DEFAULT_AGENT, GEMINI_SKILL_ENTRIES, getAgent, listAgents, validAgentNames } from './agents.js';
-import { bundleEntry, bundleSourceExists } from './commandBundles.js';
+import { DEFAULT_AGENT, GEMINI_SKILL_ENTRIES, getAgent, listAgents, resolveAgentBundles, validAgentNames } from './agents.js';
+import {
+  SUPPORTED_FRAMEWORKS,
+  bundleEntry,
+  bundleSourceExists,
+  normalizeFramework,
+  parseFrameworksInput
+} from './commandBundles.js';
 
 export async function runCli(args, context = {}) {
   const io = createIo(context);
@@ -71,6 +77,7 @@ async function initProject(parsed, io) {
   const { config, path: configPath } = loadConfig(io.cwd);
   const options = writeOptions(parsed, config);
   const agent = await resolveAgent(parsed, config, io, configPath);
+  const frameworks = await resolveFrameworks(parsed, config, io, configPath);
   const results = [];
   const artifactsDir = safeJoin(io.cwd, config.artifactsDir);
 
@@ -84,7 +91,7 @@ async function initProject(parsed, io) {
   ));
   results.push(writeManagedFile(path.join(artifactsDir, 'current', '.gitkeep'), '', options));
   results.push(writeManagedFile(path.join(artifactsDir, 'archived', '.gitkeep'), '', options));
-  results.push(createDefaultConfigFile(io.cwd, options));
+  results.push(createDefaultConfigFile(io.cwd, options, frameworks));
 
   for (const binding of agent.bindings) {
     results.push(writeManagedFile(
@@ -94,7 +101,8 @@ async function initProject(parsed, io) {
     ));
   }
 
-  for (const bundleName of agent.commandBundles) {
+  const bundlesToInstall = resolveAgentBundles(agent.id, frameworks);
+  for (const bundleName of bundlesToInstall) {
     results.push(installCommandBundle(agent, bundleName, config, options, io));
   }
 
@@ -102,7 +110,10 @@ async function initProject(parsed, io) {
     results.push(...installGlobalGeminiSkills(config, options));
   }
 
-  io.stdout(`PlanKit initialized for agent "${agent.id}".`);
+  const fwMsg = frameworks.length > 0
+    ? ` with framework suite(s): ${frameworks.join(', ')}`
+    : ' (base planning commands only)';
+  io.stdout(`PlanKit initialized for agent "${agent.id}"${fwMsg}.`);
   printResults(results, io);
 }
 
@@ -522,6 +533,93 @@ async function promptAgent(io) {
   return getAgent(trimmed) || null;
 }
 
+async function resolveFrameworks(parsed, config, io, configPath = null) {
+  const fromFlag = parsed.flags.framework || parsed.flags.frameworks;
+  if (fromFlag !== undefined) {
+    const frameworks = parseFrameworksInput(fromFlag);
+    if (frameworks.length > 0) {
+      io.stdout(`Using framework(s) from --framework flag: "${frameworks.join(', ')}".`);
+    } else {
+      io.stdout('No framework suites selected via --framework flag.');
+    }
+    return frameworks;
+  }
+
+  if (configPath && Array.isArray(config.frameworks) && config.frameworks.length > 0) {
+    io.stdout(`Using configured framework(s) "${config.frameworks.join(', ')}" from plan config.`);
+    return config.frameworks;
+  }
+
+  if (io.isTTY && io.promptChoice) {
+    const selected = await promptFrameworks(io);
+    if (selected !== null) {
+      if (selected.length > 0) {
+        io.stdout(`Selected framework(s): "${selected.join(', ')}".`);
+      } else {
+        io.stdout('Selected base planning commands only.');
+      }
+      return selected;
+    }
+  }
+
+  io.stdout('No framework suite selected — installing base planning commands only. Pass --framework <angular|vue|dotnet|none> to add framework suites.');
+  return [];
+}
+
+async function promptFrameworks(io) {
+  const promptText = `Select framework command suites to install (in addition to base planning commands):
+  1. None (Base planning commands only)
+  2. Angular command suite
+  3. Vue modernization & architecture suite
+  4. .NET clean architecture & API suite
+  5. All framework suites
+
+Enter a number (1-5), comma-separated numbers, or framework names (default: 1)`;
+
+  const validChoices = ['1', '2', '3', '4', '5', 'none', 'angular', 'vue', 'dotnet', 'all'];
+  const answer = await io.promptChoice(promptText, validChoices);
+  if (!answer || !answer.trim()) {
+    return [];
+  }
+
+  const raw = answer.trim().toLowerCase();
+  const tokens = raw.split(',').map((t) => t.trim()).filter(Boolean);
+  const result = new Set();
+
+  for (const token of tokens) {
+    if (token === '1' || token === 'none') {
+      continue;
+    }
+    if (token === '2' || token === 'angular' || token === 'ng') {
+      result.add('angular');
+      continue;
+    }
+    if (token === '3' || token === 'vue' || token === 'vuejs') {
+      result.add('vue');
+      continue;
+    }
+    if (token === '4' || token === 'dotnet' || token === '.net' || token === 'net') {
+      result.add('dotnet');
+      continue;
+    }
+    if (token === '5' || token === 'all') {
+      SUPPORTED_FRAMEWORKS.forEach((fw) => result.add(fw));
+      continue;
+    }
+
+    const normalized = normalizeFramework(token);
+    if (Array.isArray(normalized)) {
+      normalized.forEach((fw) => result.add(fw));
+    } else if (normalized) {
+      result.add(normalized);
+    } else {
+      throw new Error(`Unknown framework selection "${token}". Valid options: 1-5, ${SUPPORTED_FRAMEWORKS.join(', ')}, none, all.`);
+    }
+  }
+
+  return Array.from(result);
+}
+
 function writeOptions(parsed, config) {
   return {
     force: Boolean(parsed.flags.force) || config.overwrite === 'force',
@@ -645,6 +743,9 @@ Options:
   --dry-run                         Show intended actions without writing
   --agent <name>                    Select your coding agent during init
                                     (opencode, gemini, codex, cursor; default: opencode)
+  --framework <name>                Select framework command suite during init
+                                    (angular, vue, dotnet, none, all; default: none)
+  --frameworks <list>               Comma-separated list of framework suites during init
   --global-gemini-skills            Also install Gemini skills under the user profile
   --phases 3                        Generate N default phases during plan
   --phases "Design,Build,Test"      Generate named phases during plan

package/src/commandBundles.js

@@ -4,6 +4,24 @@ import fs from 'node:fs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
+export const SUPPORTED_FRAMEWORKS = ['angular', 'vue', 'dotnet'];
+
+export const FRAMEWORK_ALIASES = {
+  ng: 'angular',
+  angular: 'angular',
+  vue: 'vue',
+  vuejs: 'vue',
+  dotnet: 'dotnet',
+  net: 'dotnet',
+  '.net': 'dotnet'
+};
+
+export const FRAMEWORK_DESCRIPTIONS = {
+  angular: 'Angular command suite',
+  vue: 'Vue modernization & architecture suite',
+  dotnet: '.NET clean architecture & API suite'
+};
+
 export const COMMAND_BUNDLES = {
   'opencode-angular': {
     label: 'Angular command suite',
@@ -28,13 +46,100 @@ export const COMMAND_BUNDLES = {
     src: path.join('angular-commands', 'cursor'),
     dest: ['.cursor', 'rules'],
     kind: 'folder'
+  },
+  'opencode-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'opencode'),
+    dest: ['.opencode', 'commands'],
+    kind: 'folder'
+  },
+  'gemini-vue': {
+    label: 'Vue skill suite',
+    src: path.join('vue-skills', 'gemini'),
+    dest: ['.gemini', 'skills'],
+    kind: 'folder'
+  },
+  'codex-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'codex'),
+    dest: ['.codex'],
+    kind: 'folder'
+  },
+  'cursor-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'cursor'),
+    dest: ['.cursor', 'rules'],
+    kind: 'folder'
+  },
+  'opencode-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'opencode'),
+    dest: ['.opencode', 'commands'],
+    kind: 'folder'
+  },
+  'gemini-dotnet': {
+    label: '.NET skill suite',
+    src: path.join('dotnet-skills', 'gemini'),
+    dest: ['.gemini', 'skills'],
+    kind: 'folder'
+  },
+  'codex-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'codex'),
+    dest: ['.codex'],
+    kind: 'folder'
+  },
+  'cursor-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'cursor'),
+    dest: ['.cursor', 'rules'],
+    kind: 'folder'
   }
 };
 
+export function normalizeFramework(input) {
+  if (!input) return null;
+  const cleaned = String(input).trim().toLowerCase();
+  if (cleaned === 'none') return null;
+  if (cleaned === 'all') return [...SUPPORTED_FRAMEWORKS];
+  return FRAMEWORK_ALIASES[cleaned] || null;
+}
+
+export function parseFrameworksInput(input) {
+  if (!input) return [];
+  if (Array.isArray(input)) {
+    return input.flatMap((item) => parseFrameworksInput(item));
+  }
+  const parts = String(input)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  const frameworks = new Set();
+  for (const part of parts) {
+    const normalized = normalizeFramework(part);
+    if (Array.isArray(normalized)) {
+      normalized.forEach((fw) => frameworks.add(fw));
+    } else if (normalized) {
+      frameworks.add(normalized);
+    } else if (part.toLowerCase() === 'none') {
+      // explicit none
+      continue;
+    } else {
+      throw new Error(`Unknown framework "${part}". Valid frameworks: ${SUPPORTED_FRAMEWORKS.join(', ')}, none, all.`);
+    }
+  }
+  return Array.from(frameworks);
+}
+
 export function bundleEntry(bundleName) {
   return COMMAND_BUNDLES[bundleName] || null;
 }
 
+export function bundleNameFor(agentId, framework) {
+  return `${agentId}-${framework}`;
+}
+
 export function bundleSourceExists(bundleName, cwd, config) {
   const entry = COMMAND_BUNDLES[bundleName];
   if (!entry) {

package/src/config.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { AGENT_ORDER, DEFAULT_AGENT, getAgent } from './agents.js';
+import { parseFrameworksInput } from './commandBundles.js';
 
 export const DEFAULT_CONFIG = {
   artifactsDir: 'artifacts',
@@ -8,6 +9,7 @@ export const DEFAULT_CONFIG = {
   agents: {
     default: DEFAULT_AGENT
   },
+  frameworks: [],
   defaultPhases: [
     {
       title: 'Foundation & Setup',
@@ -57,9 +59,13 @@ export function loadConfig(cwd = process.cwd()) {
   };
 }
 
-export function createDefaultConfigFile(cwd, options = {}) {
+export function createDefaultConfigFile(cwd, options = {}, frameworks = []) {
   const filePath = path.join(cwd, 'plankit.config.json');
-  const content = `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`;
+  const baseConfig = structuredClone(DEFAULT_CONFIG);
+  if (Array.isArray(frameworks) && frameworks.length > 0) {
+    baseConfig.frameworks = frameworks;
+  }
+  const content = `${JSON.stringify(baseConfig, null, 2)}\n`;
   return writeManagedFile(filePath, content, options);
 }
 
@@ -69,10 +75,22 @@ export function normalizeConfig(config) {
   normalized.artifactsDir = normalized.artifactsDir || DEFAULT_CONFIG.artifactsDir;
   normalized.overwrite = normalized.overwrite || DEFAULT_CONFIG.overwrite;
   normalized.agents = normalizeAgents(normalized.agents);
+  normalized.frameworks = normalizeFrameworksConfig(normalized.frameworks);
   normalized.verification = { ...DEFAULT_CONFIG.verification, ...(normalized.verification || {}) };
   return normalized;
 }
 
+export function normalizeFrameworksConfig(frameworks) {
+  if (!frameworks) return [];
+  if (Array.isArray(frameworks)) {
+    return parseFrameworksInput(frameworks);
+  }
+  if (typeof frameworks === 'string') {
+    return parseFrameworksInput(frameworks);
+  }
+  return [];
+}
+
 export function normalizeAgents(agents) {
   if (!agents || typeof agents !== 'object') {
     return { ...DEFAULT_CONFIG.agents };

package/templates/PLANKIT.md

@@ -35,6 +35,13 @@ Prepares the phase output artifact after validating that the phase spec and prio
 
 Runs configured verification commands and archives the completed feature.
 
+## Framework Suites
+
+PlanKit supports modular framework engineering command suites selectable during `plankit init` via prompt or `--framework <angular|vue|dotnet|none|all>`:
+- **Angular**: Deterministic Angular workflows (`component-from`, `feature`, `signalize`, `modernize`, etc.)
+- **Vue**: Legacy modernization and standardization workflows (`vue-health`, `vue-pattern-map`, `vue-standardize`, `vue-modernize-slice`, etc.)
+- **.NET**: Clean Architecture & Minimal API workflows (`dotnet-health`, `dotnet-architecture-audit`, `dotnet-feature`, `dotnet-modernize`, etc.)
+
 ## Customization
 
 Configure PlanKit with `plankit.config.json`. Override generated templates by setting `templatesDir` and matching the package template file names.

package/templates/dotnet-commands/codex/dotnet-architecture-audit.md

@@ -0,0 +1,25 @@
+# dotnet-architecture-audit
+> Audit layer dependencies (Clean Architecture / Vertical Slices / DDD) and circular dependencies.
+
+# /dotnet-architecture-audit
+
+Analyze architectural layer boundaries and project references across the .NET solution.
+
+## Workflow
+1. Parse project references between .csproj files.
+2. Verify Domain layer has zero external project dependencies.
+3. Verify Application layer depends only on Domain.
+4. Detect illegal Infrastructure/API leaks into core layers or circular dependencies.
+5. Generate dependency graph and compliance matrix.
+
+## Guardrail
+Read-only architectural analysis.
+
+## Options
+- --strict            fail on any layer boundary violation
+- --json              output dependency graph as JSON
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-clean-guardrails.md

@@ -0,0 +1,24 @@
+# dotnet-clean-guardrails
+> Generate NetArchTest architectural unit tests and EditorConfig rules to guard layer boundaries.
+
+# /dotnet-clean-guardrails
+
+Enforce clean architecture layer boundaries with automated architectural unit tests and EditorConfig.
+
+## Workflow
+1. Detect solution architecture layers (Domain, Application, Infrastructure, API).
+2. Generate NetArchTest tests asserting layer boundaries (e.g. Domain should not reference Infrastructure).
+3. Generate or update .editorconfig with C# formatting, naming rules, and diagnostic severities.
+4. Run architectural tests to verify current compliance.
+
+## Guardrail
+Do not break legacy builds; apply warnings first or scope enforcement gradually.
+
+## Options
+- --netarchtest       generate NetArchTest test project
+- --editorconfig      generate .editorconfig rules
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-ef-migration.md

@@ -0,0 +1,25 @@
+# dotnet-ef-migration
+> Safe Entity Framework Core migration workflow with entity audit, SQL review, and rollback.
+
+# /dotnet-ef-migration
+
+Plan, generate, and review safe Entity Framework Core database migrations.
+
+## Workflow
+1. Audit entity configurations (Fluent API vs DataAnnotations) in target DbContext.
+2. Check for missing indexes, foreign key cascading issues, and property lengths.
+3. Generate migration with a descriptive name (dotnet ef migrations add <Name>).
+4. Generate and inspect raw migration SQL script (dotnet ef migrations script).
+5. Check for destructive schema changes (table drops, column drops, data loss warnings).
+
+## Guardrail
+Never execute irreversible or destructive migrations without explicit user confirmation.
+
+## Options
+- --name <Name>       descriptive migration name
+- --preview-sql       inspect generated SQL before applying
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-endpoint-from-model.md

@@ -0,0 +1,26 @@
+# dotnet-endpoint-from-model
+> Generate ASP.NET Core Minimal API or Controller endpoints from an entity/model with validation.
+
+# /dotnet-endpoint-from-model
+
+Generate robust CRUD endpoints from a domain model or entity.
+
+## Workflow
+1. Inspect entity/model properties, keys, and navigation properties.
+2. Generate Request/Response DTOs to avoid overposting or leaking domain entities.
+3. Generate endpoint handlers using TypedResults (Ok, Created, NotFound, ValidationProblem).
+4. Configure authorization, route groups, and OpenAPI metadata (.WithName(), .Produces()).
+5. Verify endpoint route constraints.
+
+## Guardrail
+Never expose raw database entities directly to API responses. Always map through DTOs.
+
+## Options
+- --minimal           use ASP.NET Core Minimal APIs (default)
+- --controller        use Controller-based architecture
+- --dto <Type>        use existing DTO type
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-extract-service.md

@@ -0,0 +1,25 @@
+# dotnet-extract-service
+> Refactor fat services or bloated controllers into isolated CQRS handlers or domain services.
+
+# /dotnet-extract-service
+
+Decompose fat classes into single-responsibility handlers or domain services.
+
+## Workflow
+1. Identify oversized methods or multi-responsibility service classes.
+2. Extract target method into an independent Command/Query handler or domain service.
+3. Define required interfaces and register with Microsoft.Extensions.DependencyInjection.
+4. Update caller references and ensure backward compatibility.
+5. Create unit tests for extracted handler.
+
+## Guardrail
+Preserve existing behavior and contract signatures. Do not introduce breaking API changes.
+
+## Options
+- --class <Name>      source class to refactor
+- --method <Name>     specific method to extract
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-feature.md

@@ -0,0 +1,26 @@
+# dotnet-feature
+> Build an end-to-end vertical slice feature (Command/Query, MediatR, FluentValidation, Endpoint).
+
+# /dotnet-feature
+
+Generate a complete, self-contained feature slice following Vertical Slice Architecture.
+
+## Workflow
+1. Determine feature name, operation type (Command or Query), and target domain.
+2. Generate Request and Response DTO records with immutable properties.
+3. Generate FluentValidation validator with standard validation rules.
+4. Generate MediatR / Wolverine handler with DbContext or repository access.
+5. Expose via Minimal API endpoint or Controller with TypedResults.
+6. Scaffold unit tests and integration tests.
+
+## Guardrail
+Adhere to existing solution conventions (Vertical Slices vs Clean Architecture). Do not introduce unnecessary abstractions.
+
+## Options
+- --type <command|query> operation type
+- --model <Entity>       domain entity to base feature on
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-generate-tests.md

@@ -0,0 +1,25 @@
+# dotnet-generate-tests
+> Generate xUnit/NUnit tests with FluentAssertions and WebApplicationFactory integration tests.
+
+# /dotnet-generate-tests
+
+Generate comprehensive unit and integration tests for .NET handlers, services, and endpoints.
+
+## Workflow
+1. Inspect target class (Handler, Validator, Service, or Endpoint).
+2. Generate unit tests covering valid input, boundary conditions, and error cases.
+3. Use Moq or NSubstitute for dependencies and FluentAssertions for assertions.
+4. For endpoints, generate WebApplicationFactory integration tests verifying status codes and payloads.
+5. Run tests with dotnet test.
+
+## Guardrail
+Mock only external boundaries (I/O, database, third-party APIs); test real business domain logic.
+
+## Options
+- --framework <xunit|nunit> test framework (default: xunit)
+- --integration             generate WebApplicationFactory integration tests
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.