diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index 3fdaa42..77305f1 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -17,7 +17,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: 10.0.x
         
     - name: Restore dependencies
       run: dotnet restore
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2fce985..1295602 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -19,7 +19,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: 10.0.x
 
     - name: Build Binaries
       run: |
@@ -29,9 +29,13 @@ jobs:
     - name: Build Debian Package
       run: |
         chmod +x build_deb.sh
-        VERSION=${{ github.ref_name }}
-        VERSION=${VERSION#V.}
-        ./build_deb.sh $VERSION
+        # Accepts v1.1.0, V1.1.0, V.1.1.0 or 1.1.0. Debian versions must start
+        # with a digit, so the leading tag prefix has to go.
+        VERSION="${{ github.ref_name }}"
+        VERSION="${VERSION#[vV]}"
+        VERSION="${VERSION#.}"
+        echo "Packaging version: $VERSION"
+        ./build_deb.sh "$VERSION"
 
     - name: Pack NuGet Tool
       run: dotnet pack MTC/MTC.csproj -c Release -o nupkg
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..943be41
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,131 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.0] — unreleased
+
+Maintenance release after an eight-month pause. Everything now targets .NET 10, the
+template engine vulnerability is closed, and the code MTC generates compiles without
+warnings.
+
+### Security
+
+- Updated Scriban from 6.5.2 to 7.2.6, closing 14 known advisories — one critical
+  and eight high severity. Scriban renders every template, so this affected all
+  generated output.
+- Generated Web/API projects now pin `Microsoft.OpenApi` 2.11.0. The version pulled in
+  transitively by `Microsoft.AspNetCore.OpenApi` carries a known advisory
+  (GHSA-v5pm-xwqc-g5wc).
+- Rendered file and directory names can no longer escape the output directory. A name
+  such as `../Escaped` previously wrote files into the parent directory; it is now
+  refused with a clear error.
+
+### Added
+
+- **Generate commands no longer overwrite existing files.** Every command now checks its
+  targets before writing anything. If a file it would produce already exists, nothing is
+  written, the conflicting paths are listed, and the command exits with code 1. Pass
+  `--force` to replace them. Generation is all-or-nothing, so a conflict can no longer
+  leave a half-written feature behind. Applies to `new`, `add feature`,
+  `add value-object` and `add dto`, including the Clean Architecture path that renders
+  through a temporary directory.
+- `mtc new <template> <name>` now accepts the project name as a positional argument.
+  `--name`/`-n` still works and takes precedence when both are given.
+- Reference-typed properties are generated with the `required` modifier, so scaffolded
+  projects compile clean under `<Nullable>enable</Nullable>`.
+- New field type aliases: `long`, `short`, `byte`, `float`, `double`, `char`,
+  `dateonly` and `timeonly`.
+- `CONTRIBUTING.md` and this changelog.
+- Thirteen new unit tests covering type mapping, malformed input and value-type
+  detection (7 tests to 20).
+
+### Changed
+
+- Target framework moved from `net9.0` to `net10.0`, in MTC itself, both test projects
+  and all seven generated project templates. .NET 9 has reached end of support.
+- Templates render with controlled whitespace, so generated files are indented like
+  hand-written code instead of carrying stray blank lines and doubled indentation.
+- Dependencies updated: Spectre.Console 0.54.0 to 0.57.2, `Microsoft.Extensions.*`
+  10.0.0 to 10.0.10.
+- Generated projects now reference ASP.NET Core and EF Core 10.0.10. MediatR is
+  pinned at 12.4.1 across all templates, which previously disagreed with each other.
+- Failure messages point at the command that helps: a missing template suggests
+  `mtc list`, undetected architecture suggests `mtc debug-context`.
+- `add value-object` and `add dto` were near-identical copies and now share one
+  implementation.
+- Integration tests locate the built binary by searching, instead of hardcoding a
+  target framework directory.
+
+### Fixed
+
+- `mtc new ConsoleApp MyApp` — the form documented in the README — failed with an
+  unrecognized argument error. The project name was only accepted via `--name`.
+- The default project name resolved to a literal `"."` when neither `--name` nor an
+  output directory was given.
+- Commands exited with code 0 after reporting an error, so scripts and CI could not
+  detect failures.
+- `add feature`, `add value-object` and `add dto` shared single `Argument`/`Option`
+  instances, making parsing dependent on registration order.
+- Debug output leaked into normal runs, from both `mtc new` and the scaffolding service.
+- Generated entities, DTOs and value objects raised CS8618 nullability warnings.
+- The release workflow only stripped a literal `V.` tag prefix, while the workflow
+  triggers on `v*` and `V*`. A `v1.1.0` tag produced a Debian version string starting
+  with a letter, which `dpkg-deb` rejects. All four tag spellings are now handled.
+
+### Removed
+
+- Two empty `UnitTest1.cs` placeholder files.
+
+## [1.0.2] — 2025-12-07
+
+### Added
+
+- README is now included in the NuGet package.
+
+### Changed
+
+- Removed the PPA publishing steps from the release workflow. Debian users are served
+  by the `.deb` artifact instead.
+
+## [1.0.1] — 2025-12-07
+
+### Added
+
+- MIT License file.
+- Manual workflow dispatch trigger for releases, and support for uppercase version tags.
+- AUR installation instructions and a complete CLI reference in the README.
+- OS-specific instructions for installing the standalone binaries.
+
+### Changed
+
+- Publish trimming disabled, which was corrupting the shipped template directory.
+- Template directory is copied cleanly on publish.
+- Template service error handling refined.
+
+### Fixed
+
+- `ls` invocation in the publish script.
+
+## [1.0.0] — 2025-12-06
+
+First public release.
+
+### Added
+
+- `mtc new` with four project templates: `ConsoleApp`, `MvcMonolith`, `CleanArch` and
+  `VerticalSlice`.
+- `mtc add feature`, which detects whether the current solution uses Clean Architecture,
+  MVC or Vertical Slice and writes each generated file into the matching layer.
+- `mtc add value-object` and `mtc add dto`.
+- `mtc list`, `mtc config` (`set`/`get`/`list`) and `mtc debug-context`.
+- Field definitions via `--fields "Name:string Price:decimal"`.
+- Distribution as a .NET global tool, an AUR package, a `.deb`, and standalone binaries
+  for Windows, Linux and macOS.
+
+[1.1.0]: https://github.com/JuansesDev/MTC/compare/V.1.0.2...HEAD
+[1.0.2]: https://github.com/JuansesDev/MTC/compare/V.1.0.1...V.1.0.2
+[1.0.1]: https://github.com/JuansesDev/MTC/compare/V.1.0.0...V.1.0.1
+[1.0.0]: https://github.com/JuansesDev/MTC/releases/tag/V.1.0.0
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..52ea0cc
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,175 @@
+# Contributing to MTC
+
+Thanks for taking the time. MTC is a small project, so the process is light — the only
+hard rule is that `dotnet build` and `dotnet test` must be clean before a PR.
+
+## Getting set up
+
+You need the [.NET 10 SDK](https://dotnet.microsoft.com/download). Nothing else.
+
+```bash
+git clone https://github.com/JuansesDev/MTC.git
+cd MTC
+dotnet build
+dotnet test
+```
+
+The build should finish with **0 warnings**. If you see warnings that were not there
+before your change, they count as breakage.
+
+### Running your build
+
+`dotnet run` swallows CLI arguments in confusing ways, so drive the binary directly:
+
+```bash
+dotnet build
+./MTC/bin/Debug/net10.0/MTC list
+```
+
+A good scratch loop is to generate into a throwaway directory and inspect the result:
+
+```bash
+mkdir -p /tmp/mtc-scratch && cd /tmp/mtc-scratch
+/path/to/MTC/MTC/bin/Debug/net10.0/MTC new CleanArch MyShop
+/path/to/MTC/MTC/bin/Debug/net10.0/MTC add feature Product --fields "Name:string Price:decimal"
+dotnet build MyShop.sln    # generated projects must compile clean too
+```
+
+## How the code is laid out
+
+| Path | What lives there |
+|---|---|
+| `MTC/Program.cs` | CLI command definitions and handlers |
+| `MTC/Services/` | The real logic — one interface + implementation per concern |
+| `MTC/Models/` | Plain data types (`Template`, `Property`, `ProjectContext`) |
+| `Templates/` | The templates themselves, copied to the build output |
+| `MTC.Tests/` | Unit tests |
+| `MTC.IntegrationTests/` | Tests that run the compiled binary end to end |
+
+The services worth knowing:
+
+- **`ContextService`** — walks up from the current directory to find a `.sln`, then decides
+  whether the solution is Clean Architecture, Vertical Slice or MVC.
+- **`TemplateService`** — discovers templates by scanning recursively for `manifest.json`.
+- **`ScribanTemplateRenderer`** — renders template content *and* file/directory names.
+- **`ScaffoldingService`** — walks a template directory and writes the rendered result.
+- **`FieldParser`** — turns `"Name:string Price:decimal"` into `Property` objects.
+
+## Adding or editing a template
+
+A template is just a directory with a `manifest.json` and the files to render. Both file
+**contents** and file/directory **names** go through Scriban, which is why you see paths
+like `Templates/Common/Dto/{{Name}}.cs`.
+
+```json
+{
+    "Name": "MyTemplate",
+    "Description": "What it generates",
+    "Version": "1.0.0",
+    "Author": "You",
+    "Tags": ["Tag"],
+    "Variables": { "Name": "string" }
+}
+```
+
+`Name` is what users type (`mtc new MyTemplate ...`), so it must be unique.
+
+### Variables available in templates
+
+| Variable | Available in | Notes |
+|---|---|---|
+| `Name` | everywhere | the entity/project name the user typed |
+| `ProjectName` | `add feature` | taken from the `.sln` file name |
+| `Namespace` | `add value-object`, `add dto` | resolved from the detected architecture |
+| `Properties` | `add *` | list of `{ Name, Type, IsValueType }` |
+
+Member names are case-sensitive: write `{{ prop.Name }}`, not `{{ prop.name }}`.
+
+### Two conventions that matter
+
+**1. Control whitespace, or the output looks generated.** Use `{{~` and `~}}` around
+loops so the rendered file is indented like hand-written code:
+
+```
+public class {{Name}}
+{
+{{~ for prop in Properties ~}}
+    public {{ prop.Type }} {{ prop.Name }} { get; set; }
+{{~ end ~}}
+}
+```
+
+**2. Emit `required` for reference types.** Generated projects have
+`<Nullable>enable</Nullable>`, so a plain `public string Name { get; set; }` raises CS8618.
+That is what `IsValueType` is for:
+
+```
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; set; }
+```
+
+**Anything MTC generates must compile with zero warnings.** Always build the generated
+solution before opening a PR, not just MTC itself.
+
+## Tests
+
+- Put unit tests in `MTC.Tests`, next to the service they cover.
+- `MTC.IntegrationTests` runs the compiled binary, so it needs a build first. It locates
+  the executable by searching `MTC/bin/Debug/` — don't hardcode a framework folder.
+- New behaviour needs a test. Bug fixes should come with a test that fails without the fix.
+
+## Style
+
+Follow the surrounding code; there is no separate style config.
+
+- 4 spaces, file-scoped namespaces, nullable enabled.
+- Services go behind an interface and get registered in `Program.cs`.
+- Commands report failures with `AnsiConsole.MarkupLine("[red]Error:[/] ...")` **and** set
+  `Environment.ExitCode = 1`. Silent failures with exit code 0 break scripted use.
+- Prefer a short explanatory comment over a long one. Don't commit commented-out code or
+  notes to yourself.
+
+## Pull requests
+
+1. Branch off `main`.
+2. Keep the change focused — one concern per PR.
+3. Make sure `dotnet build` and `dotnet test` are clean.
+4. Add an entry under `## [Unreleased]` in [CHANGELOG.md](CHANGELOG.md). Describe the
+   effect on users, not the diff.
+5. Say what you changed and why. If it changes CLI behaviour, update the README too.
+
+CI runs build and tests on every push and PR to `main`.
+
+## Releasing (maintainers)
+
+Version numbers live in **two** places and must match:
+
+- `MTC/MTC.csproj` → `<Version>`
+- `publish.sh` → `VERSION`
+
+Rename the `## [Unreleased]` heading in `CHANGELOG.md` to the version and date, then tag
+and push:
+
+```bash
+git tag v1.1.0
+git push origin v1.1.0
+```
+
+Tags may be written `v1.1.0`, `V1.1.0`, `V.1.1.0` or `1.1.0` — the workflow strips the
+prefix either way. Releases up to 1.0.2 used the `V.` form.
+
+The release workflow builds the cross-platform binaries and the `.deb`, publishes the
+GitHub release, and pushes the package to NuGet. AUR is published separately with
+`./publish_aur.sh`.
+
+## Reporting bugs
+
+Open an issue with the MTC version, your OS, the exact command, what you expected, and
+what happened. For anything about architecture detection, include the output of:
+
+```bash
+mtc debug-context
+```
+
+## License
+
+Contributions are accepted under the [MIT License](LICENSE).
diff --git a/MTC.IntegrationTests/CliTests.cs b/MTC.IntegrationTests/CliTests.cs
index 92ebc1f..2b6fb12 100644
--- a/MTC.IntegrationTests/CliTests.cs
+++ b/MTC.IntegrationTests/CliTests.cs
@@ -25,13 +25,30 @@ public CliTests()
              throw new DirectoryNotFoundException("Could not find MTC.sln in parent directories.");
         }
 
-        var solutionDir = currentDir.FullName;
-        _mtcPath = Path.Combine(solutionDir, "MTC/bin/Debug/net9.0/MTC");
-        
-        if (!File.Exists(_mtcPath))
+        _mtcPath = ResolveMtcBinary(currentDir.FullName);
+    }
+
+    /// <summary>
+    /// Locates the built MTC executable without hardcoding a target framework,
+    /// so the tests keep working across .NET upgrades.
+    /// </summary>
+    private static string ResolveMtcBinary(string solutionDir)
+    {
+        var binDir = Path.Combine(solutionDir, "MTC", "bin", "Debug");
+        var executableName = OperatingSystem.IsWindows() ? "MTC.exe" : "MTC";
+
+        var candidates = Directory.Exists(binDir)
+            ? Directory.GetFiles(binDir, executableName, SearchOption.AllDirectories)
+            : Array.Empty<string>();
+
+        if (candidates.Length == 0)
         {
-             throw new FileNotFoundException($"MTC binary not found at {_mtcPath}. Please build the solution first.");
+            throw new FileNotFoundException(
+                $"MTC binary '{executableName}' not found under {binDir}. Build the solution first (dotnet build).");
         }
+
+        // Most recent build wins, so the tests follow the framework currently targeted.
+        return candidates.OrderByDescending(File.GetLastWriteTimeUtc).First();
     }
 
     public void Dispose()
diff --git a/MTC.IntegrationTests/MTC.IntegrationTests.csproj b/MTC.IntegrationTests/MTC.IntegrationTests.csproj
index 627a60e..99a06dc 100644
--- a/MTC.IntegrationTests/MTC.IntegrationTests.csproj
+++ b/MTC.IntegrationTests/MTC.IntegrationTests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
@@ -18,4 +18,10 @@
     <Using Include="Xunit" />
   </ItemGroup>
 
+  <!-- The tests drive the built executable rather than the library, but the reference
+       guarantees MTC is built before this project. -->
+  <ItemGroup>
+    <ProjectReference Include="..\MTC\MTC.csproj" />
+  </ItemGroup>
+
 </Project>
diff --git a/MTC.IntegrationTests/UnitTest1.cs b/MTC.IntegrationTests/UnitTest1.cs
deleted file mode 100644
index c9dd2f3..0000000
--- a/MTC.IntegrationTests/UnitTest1.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace MTC.IntegrationTests;
-
-public class UnitTest1
-{
-    [Fact]
-    public void Test1()
-    {
-
-    }
-}
diff --git a/MTC.Tests/FieldParserTests.cs b/MTC.Tests/FieldParserTests.cs
index 948c4b0..26907e7 100644
--- a/MTC.Tests/FieldParserTests.cs
+++ b/MTC.Tests/FieldParserTests.cs
@@ -49,13 +49,57 @@ public void Parse_ShouldHandleExtraSpaces()
     }
 
     [Fact]
-    public void Parse_ShouldDefaultToString_WhenTypeIsMissing()
-    {
-        // Assuming FieldParser defaults to string if no type provided, 
-        // or throws? Let's check implementation behavior or define expected behavior.
-        // Current implementation splits by ':' so "Name" might fail or set Type to empty.
-        // Let's assume input MUST be Name:Type for now based on usage.
-        // If implementation allows "Name", let's test it.
-        // For now, let's stick to standard "Name:Type".
+    public void Parse_ShouldSkipFields_WhenTypeIsMissing()
+    {
+        var result = _parser.Parse("Name Age:int");
+
+        Assert.Single(result);
+        Assert.Equal("Age", result[0].Name);
+    }
+
+    [Theory]
+    [InlineData("datetime", "DateTime")]
+    [InlineData("dateonly", "DateOnly")]
+    [InlineData("timeonly", "TimeOnly")]
+    [InlineData("guid", "Guid")]
+    [InlineData("STRING", "string")]
+    public void Parse_ShouldNormalizeKnownTypeAliases(string alias, string expected)
+    {
+        var result = _parser.Parse($"Value:{alias}");
+
+        Assert.Equal(expected, result[0].Type);
+    }
+
+    [Fact]
+    public void Parse_ShouldPassThroughUnknownTypes()
+    {
+        var result = _parser.Parse("Status:OrderStatus");
+
+        Assert.Equal("OrderStatus", result[0].Type);
+    }
+
+    [Theory]
+    [InlineData("int")]
+    [InlineData("decimal")]
+    [InlineData("bool")]
+    [InlineData("datetime")]
+    [InlineData("guid")]
+    public void Parse_ShouldMarkBuiltInValueTypes(string type)
+    {
+        var result = _parser.Parse($"Value:{type}");
+
+        Assert.True(result[0].IsValueType);
+    }
+
+    [Theory]
+    [InlineData("string")]
+    [InlineData("OrderStatus")]
+    public void Parse_ShouldNotMarkReferenceTypesAsValueTypes(string type)
+    {
+        // Reference types drive the 'required' modifier in the generated code,
+        // which is what keeps scaffolded projects free of CS8618.
+        var result = _parser.Parse($"Value:{type}");
+
+        Assert.False(result[0].IsValueType);
     }
 }
diff --git a/MTC.Tests/MTC.Tests.csproj b/MTC.Tests/MTC.Tests.csproj
index 7c39c4d..c2d1d30 100644
--- a/MTC.Tests/MTC.Tests.csproj
+++ b/MTC.Tests/MTC.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
diff --git a/MTC.Tests/ScaffoldingServiceTests.cs b/MTC.Tests/ScaffoldingServiceTests.cs
new file mode 100644
index 0000000..285845a
--- /dev/null
+++ b/MTC.Tests/ScaffoldingServiceTests.cs
@@ -0,0 +1,155 @@
+using MTC.Models;
+using MTC.Services;
+using Xunit;
+
+namespace MTC.Tests;
+
+public class ScaffoldingServiceTests : IDisposable
+{
+    private readonly ScaffoldingService _service = new(new ScribanTemplateRenderer());
+    private readonly string _templateDir;
+    private readonly string _targetDir;
+
+    public ScaffoldingServiceTests()
+    {
+        var root = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        _templateDir = Path.Combine(root, "template");
+        _targetDir = Path.Combine(root, "target");
+        Directory.CreateDirectory(_templateDir);
+        Directory.CreateDirectory(_targetDir);
+    }
+
+    public void Dispose()
+    {
+        var root = Path.GetDirectoryName(_templateDir);
+        if (root != null && Directory.Exists(root))
+        {
+            Directory.Delete(root, true);
+        }
+    }
+
+    private Template GivenTemplate(params (string Name, string Content)[] files)
+    {
+        foreach (var (name, content) in files)
+        {
+            var path = Path.Combine(_templateDir, name);
+            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+            File.WriteAllText(path, content);
+        }
+
+        return new Template(new TemplateManifest { Name = "Test" }, _templateDir);
+    }
+
+    private static Dictionary<string, object> Variables(string name) =>
+        new() { { "Name", name } };
+
+    [Fact]
+    public async Task GenerateAsync_ShouldRenderNamesAndContent()
+    {
+        var template = GivenTemplate(("{{Name}}.cs", "class {{Name}} { }"));
+
+        var result = await _service.GenerateAsync(template, _targetDir, Variables("Product"));
+
+        Assert.True(result.Succeeded);
+        var written = Path.Combine(_targetDir, "Product.cs");
+        Assert.True(File.Exists(written));
+        Assert.Equal("class Product { }", File.ReadAllText(written));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldSkipManifest()
+    {
+        var template = GivenTemplate(("manifest.json", "{}"), ("{{Name}}.cs", "x"));
+
+        await _service.GenerateAsync(template, _targetDir, Variables("Product"));
+
+        Assert.False(File.Exists(Path.Combine(_targetDir, "manifest.json")));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldNotOverwrite_WhenFileExists()
+    {
+        var template = GivenTemplate(("{{Name}}.cs", "generated"));
+        var existing = Path.Combine(_targetDir, "Product.cs");
+        File.WriteAllText(existing, "hand written");
+
+        var result = await _service.GenerateAsync(template, _targetDir, Variables("Product"));
+
+        Assert.False(result.Succeeded);
+        Assert.Equal(existing, Assert.Single(result.ConflictingFiles));
+        Assert.Equal("hand written", File.ReadAllText(existing));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldWriteNothing_WhenAnyFileConflicts()
+    {
+        var template = GivenTemplate(
+            ("{{Name}}.cs", "generated"),
+            ("Other.cs", "generated"));
+
+        File.WriteAllText(Path.Combine(_targetDir, "Product.cs"), "hand written");
+
+        var result = await _service.GenerateAsync(template, _targetDir, Variables("Product"));
+
+        Assert.False(result.Succeeded);
+        // The non-conflicting file must not be written either: generation is all-or-nothing.
+        Assert.False(File.Exists(Path.Combine(_targetDir, "Other.cs")));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldOverwrite_WhenForced()
+    {
+        var template = GivenTemplate(("{{Name}}.cs", "generated"));
+        var existing = Path.Combine(_targetDir, "Product.cs");
+        File.WriteAllText(existing, "hand written");
+
+        var result = await _service.GenerateAsync(template, _targetDir, Variables("Product"), overwrite: true);
+
+        Assert.True(result.Succeeded);
+        Assert.Equal(existing, Assert.Single(result.OverwrittenFiles));
+        Assert.Equal("generated", File.ReadAllText(existing));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldReportOnlyReplacedFilesAsOverwritten()
+    {
+        var template = GivenTemplate(("{{Name}}.cs", "generated"), ("Other.cs", "generated"));
+        File.WriteAllText(Path.Combine(_targetDir, "Product.cs"), "hand written");
+
+        var result = await _service.GenerateAsync(template, _targetDir, Variables("Product"), overwrite: true);
+
+        Assert.Equal(2, result.CreatedFiles.Count);
+        Assert.Single(result.OverwrittenFiles);
+    }
+
+    [Theory]
+    [InlineData("../Escaped")]
+    [InlineData("../../Escaped")]
+    public async Task GenerateAsync_ShouldRefuseToWriteOutsideTarget(string name)
+    {
+        var template = GivenTemplate(("{{Name}}.cs", "generated"));
+
+        await Assert.ThrowsAsync<ScaffoldingException>(
+            () => _service.GenerateAsync(template, _targetDir, Variables(name)));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldRefuseTraversalThroughDirectoryNames()
+    {
+        var template = GivenTemplate((Path.Combine("{{Name}}", "File.cs"), "generated"));
+
+        await Assert.ThrowsAsync<ScaffoldingException>(
+            () => _service.GenerateAsync(template, _targetDir, Variables("../Escaped")));
+    }
+
+    [Fact]
+    public async Task GenerateAsync_ShouldCreateNestedDirectories()
+    {
+        var template = GivenTemplate((Path.Combine("Features", "{{Name}}", "Handler.cs"), "class {{Name}} { }"));
+
+        var result = await _service.GenerateAsync(template, _targetDir, Variables("Order"));
+
+        Assert.True(result.Succeeded);
+        Assert.True(File.Exists(Path.Combine(_targetDir, "Features", "Order", "Handler.cs")));
+    }
+}
diff --git a/MTC.Tests/UnitTest1.cs b/MTC.Tests/UnitTest1.cs
deleted file mode 100644
index 9122899..0000000
--- a/MTC.Tests/UnitTest1.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace MTC.Tests;
-
-public class UnitTest1
-{
-    [Fact]
-    public void Test1()
-    {
-
-    }
-}
diff --git a/MTC/MTC.csproj b/MTC/MTC.csproj
index dad6a36..5065bbd 100644
--- a/MTC/MTC.csproj
+++ b/MTC/MTC.csproj
@@ -2,24 +2,24 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <!-- NuGet Package Settings -->
     <PackAsTool>true</PackAsTool>
     <ToolCommandName>mtc</ToolCommandName>
     <PackageId>MTC</PackageId>
-    <Version>1.0.2</Version>
+    <Version>1.1.0</Version>
     <Authors>Juanse</Authors>
     <Description>Modular Template CLI for .NET</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.0" />
-    <PackageReference Include="Scriban" Version="6.5.2" />
-    <PackageReference Include="Spectre.Console" Version="0.54.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.10" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.10" />
+    <PackageReference Include="Scriban" Version="7.2.6" />
+    <PackageReference Include="Spectre.Console" Version="0.57.2" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
   </ItemGroup>
 
diff --git a/MTC/Models/Property.cs b/MTC/Models/Property.cs
index ed11c73..52045cd 100644
--- a/MTC/Models/Property.cs
+++ b/MTC/Models/Property.cs
@@ -4,4 +4,11 @@ public class Property
 {
     public string Name { get; set; } = string.Empty;
     public string Type { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Whether the type is a value type. Templates use this to decide whether a
+    /// property needs the <c>required</c> modifier: reference types left
+    /// unassigned trigger CS8618 in projects with nullable enabled.
+    /// </summary>
+    public bool IsValueType { get; set; }
 }
diff --git a/MTC/Models/ScaffoldResult.cs b/MTC/Models/ScaffoldResult.cs
new file mode 100644
index 0000000..2dfa4c1
--- /dev/null
+++ b/MTC/Models/ScaffoldResult.cs
@@ -0,0 +1,35 @@
+namespace MTC.Models;
+
+/// <summary>
+/// Outcome of a scaffolding run. Generation is all-or-nothing: when the target
+/// already holds files the run would replace, nothing is written and the paths
+/// are reported back in <see cref="ConflictingFiles"/>.
+/// </summary>
+public class ScaffoldResult
+{
+    public bool Succeeded { get; private init; }
+
+    /// <summary>Files written, including any that replaced an existing file.</summary>
+    public IReadOnlyList<string> CreatedFiles { get; private init; } = Array.Empty<string>();
+
+    /// <summary>Subset of <see cref="CreatedFiles"/> that replaced existing content.</summary>
+    public IReadOnlyList<string> OverwrittenFiles { get; private init; } = Array.Empty<string>();
+
+    /// <summary>Existing files that blocked the run. Only set when it failed.</summary>
+    public IReadOnlyList<string> ConflictingFiles { get; private init; } = Array.Empty<string>();
+
+    public static ScaffoldResult Written(IReadOnlyList<string> created, IReadOnlyList<string> overwritten) =>
+        new()
+        {
+            Succeeded = true,
+            CreatedFiles = created,
+            OverwrittenFiles = overwritten
+        };
+
+    public static ScaffoldResult BlockedBy(IReadOnlyList<string> conflicts) =>
+        new()
+        {
+            Succeeded = false,
+            ConflictingFiles = conflicts
+        };
+}
diff --git a/MTC/Program.cs b/MTC/Program.cs
index 772f6ec..a7f650c 100644
--- a/MTC/Program.cs
+++ b/MTC/Program.cs
@@ -4,6 +4,7 @@
 using System.CommandLine;
 using System.CommandLine.Builder;
 using System.CommandLine.Parsing;
+using MTC.Models;
 using MTC.Services;
 
 namespace MTC;
@@ -41,14 +42,20 @@ static async Task Main(string[] args)
         // 'new' command
         var newCommand = new Command("new", "Create a new project from a template");
         var templateNameArg = new Argument<string>("template-name", "The name of the template to use");
+        var projectNameArg = new Argument<string>("name", () => string.Empty,
+            "The name of the project. Defaults to the output directory name.");
         var outputOption = new Option<string>(new[] { "--output", "-o" }, () => ".", "The output directory");
-        var nameOption = new Option<string>(new[] { "--name", "-n" }, "The name of the project");
+        var nameOption = new Option<string>(new[] { "--name", "-n" }, () => string.Empty,
+            "The name of the project. Alternative to the positional argument.");
+        var newForceOption = new Option<bool>("--force", "Overwrite files that already exist");
 
         newCommand.AddArgument(templateNameArg);
+        newCommand.AddArgument(projectNameArg);
         newCommand.AddOption(outputOption);
         newCommand.AddOption(nameOption);
+        newCommand.AddOption(newForceOption);
 
-        newCommand.SetHandler(async (string templateName, string output, string name) =>
+        newCommand.SetHandler(async (string templateName, string positionalName, string output, string nameFromOption, bool force) =>
         {
             var templateService = host.Services.GetRequiredService<ITemplateService>();
             var scaffoldingService = host.Services.GetRequiredService<IScaffoldingService>();
@@ -57,20 +64,22 @@ static async Task Main(string[] args)
             if (template == null)
             {
                 AnsiConsole.MarkupLine($"[red]Error:[/] Template '{templateName}' not found.");
+                AnsiConsole.MarkupLine("Run [green]mtc list[/] to see the available templates.");
+                Environment.ExitCode = 1;
                 return;
             }
 
-            // Default output to current directory if not specified
-            if (string.IsNullOrEmpty(output))
+            if (string.IsNullOrWhiteSpace(output))
             {
                 output = Directory.GetCurrentDirectory();
             }
 
-            // Default name to output directory name if not specified
-            if (string.IsNullOrEmpty(name))
-            {
-                name = new DirectoryInfo(output).Name;
-            }
+            // --name wins over the positional argument; otherwise fall back to the
+            // output directory name. GetFullPath matters here: "." would otherwise
+            // resolve to a literal "." instead of the directory it points at.
+            var name = !string.IsNullOrWhiteSpace(nameFromOption) ? nameFromOption
+                     : !string.IsNullOrWhiteSpace(positionalName) ? positionalName
+                     : new DirectoryInfo(Path.GetFullPath(output)).Name;
 
             var variables = new Dictionary<string, object>
             {
@@ -79,12 +88,15 @@ static async Task Main(string[] args)
             };
 
             AnsiConsole.MarkupLine($"[bold green]Creating project '{name}' from template '{templateName}'...[/]");
-            AnsiConsole.MarkupLine($"[yellow]Debug:[/] Template Directory: {template.RootPath}");
-            
-            try 
+
+            try
             {
-                await scaffoldingService.GenerateAsync(template, output, variables);
-                AnsiConsole.MarkupLine("[bold green]Done![/]");
+                Report(await scaffoldingService.GenerateAsync(template, output, variables, force));
+            }
+            catch (ScaffoldingException ex)
+            {
+                AnsiConsole.MarkupLine($"[red]Error:[/] {Markup.Escape(ex.Message)}");
+                Environment.ExitCode = 1;
             }
             catch (Exception ex)
             {
@@ -92,22 +104,36 @@ static async Task Main(string[] args)
                 Environment.ExitCode = 1;
             }
 
-        }, templateNameArg, outputOption, nameOption);
+        }, templateNameArg, projectNameArg, outputOption, nameOption, newForceOption);
 
         rootCommand.AddCommand(newCommand);
 
         // 'add' command group
         var addCommand = new Command("add", "Add a new item to the project");
-        
+
+        // Each subcommand needs its own Argument/Option instances. Sharing a single
+        // instance across commands makes parsing depend on registration order.
+        static Argument<string> NameArgument(string description) =>
+            new Argument<string>("name", description);
+
+        static Option<string> FieldsOption() =>
+            new Option<string>("--fields", () => string.Empty,
+                "The fields of the entity (e.g. 'Name:string Price:decimal')");
+
+        static Option<bool> ForceOption() =>
+            new Option<bool>("--force", "Overwrite files that already exist");
+
         // 'add feature' command
         var addFeatureCommand = new Command("feature", "Add a new feature slice");
-        var featureNameArg = new Argument<string>("name", "The name of the feature");
-        var fieldsOption = new Option<string>("--fields", "The fields of the entity (e.g. 'Name:string Price:decimal')");
+        var featureNameArg = NameArgument("The name of the feature");
+        var fieldsOption = FieldsOption();
+        var featureForceOption = ForceOption();
 
         addFeatureCommand.AddArgument(featureNameArg);
         addFeatureCommand.AddOption(fieldsOption);
+        addFeatureCommand.AddOption(featureForceOption);
 
-        addFeatureCommand.SetHandler(async (string name, string fields) =>
+        addFeatureCommand.SetHandler(async (string name, string fields, bool force) =>
         {
             var contextService = host.Services.GetRequiredService<IContextService>();
             var templateService = host.Services.GetRequiredService<ITemplateService>();
@@ -119,13 +145,16 @@ static async Task Main(string[] args)
 
             if (context.Architecture == MTC.Models.Architecture.Unknown)
             {
-                AnsiConsole.MarkupLine("[red]Error:[/] Unknown project architecture.");
+                AnsiConsole.MarkupLine("[red]Error:[/] Could not detect the project architecture.");
+                AnsiConsole.MarkupLine("Run [green]mtc debug-context[/] from inside your solution to see what MTC found.");
+                Environment.ExitCode = 1;
                 return;
             }
 
             if (string.IsNullOrEmpty(context.SolutionPath))
             {
-                AnsiConsole.MarkupLine("[red]Error:[/] Could not find solution file.");
+                AnsiConsole.MarkupLine("[red]Error:[/] Could not find a .sln file in this directory or any parent.");
+                Environment.ExitCode = 1;
                 return;
             }
 
@@ -146,56 +175,90 @@ static async Task Main(string[] args)
 
             if (context.Architecture == MTC.Models.Architecture.VerticalSlice)
             {
-                // Vertical Slice Logic
-                string featuresPath = string.Empty;
                 var featuresDirs = Directory.GetDirectories(context.SolutionDirectory, "Features", SearchOption.AllDirectories);
                 if (featuresDirs.Length == 0)
                 {
-                     AnsiConsole.MarkupLine("[red]Error:[/] Could not find 'Features' directory.");
-                     return;
+                    AnsiConsole.MarkupLine("[red]Error:[/] Could not find a 'Features' directory in the solution.");
+                    Environment.ExitCode = 1;
+                    return;
                 }
-                featuresPath = featuresDirs[0]; 
-                var targetDir = Path.Combine(featuresPath, name);
-                
+
+                var featuresPath = featuresDirs[0];
                 var template = templateService.GetTemplate("VerticalSliceFeature");
-                if (template == null) { AnsiConsole.MarkupLine("[red]Error:[/] Template 'VerticalSliceFeature' not found."); return; }
+                if (template == null)
+                {
+                    AnsiConsole.MarkupLine("[red]Error:[/] Template 'VerticalSliceFeature' not found.");
+                    Environment.ExitCode = 1;
+                    return;
+                }
 
-                AnsiConsole.MarkupLine($"[bold green]Creating feature '{name}' in '{featuresPath}'...[/]");
-                try { await scaffoldingService.GenerateAsync(template, featuresPath, variables); AnsiConsole.MarkupLine("[bold green]Done![/]"); }
-                catch (Exception ex) { AnsiConsole.WriteException(ex); }
+                AnsiConsole.MarkupLine($"[bold green]Creating feature '{name}' in '{ToDisplayPath(featuresPath)}'...[/]");
+                try
+                {
+                    Report(await scaffoldingService.GenerateAsync(template, featuresPath, variables, force));
+                }
+                catch (ScaffoldingException ex)
+                {
+                    AnsiConsole.MarkupLine($"[red]Error:[/] {Markup.Escape(ex.Message)}");
+                    Environment.ExitCode = 1;
+                }
+                catch (Exception ex)
+                {
+                    AnsiConsole.WriteException(ex);
+                    Environment.ExitCode = 1;
+                }
             }
             else if (context.Architecture == MTC.Models.Architecture.MvcMonolith)
             {
-                // MVC Logic
                 var template = templateService.GetTemplate("MvcFeature");
-                if (template == null) { AnsiConsole.MarkupLine("[red]Error:[/] Template 'MvcFeature' not found."); return; }
+                if (template == null)
+                {
+                    AnsiConsole.MarkupLine("[red]Error:[/] Template 'MvcFeature' not found.");
+                    Environment.ExitCode = 1;
+                    return;
+                }
 
-                // Target is the project root containing Controllers/Models/Views
-                // We assume the current directory is the project root or we can find it
-                // For simplicity, let's use context.SolutionDirectory and find the project folder
-                var projectDir = Directory.GetDirectories(context.SolutionDirectory).FirstOrDefault(d => Directory.Exists(Path.Combine(d, "Controllers")));
-                if (projectDir == null) { AnsiConsole.MarkupLine("[red]Error:[/] Could not find MVC project root."); return; }
+                // The MVC project is the one holding the Controllers folder.
+                var projectDir = Directory.GetDirectories(context.SolutionDirectory)
+                    .FirstOrDefault(d => Directory.Exists(Path.Combine(d, "Controllers")));
 
-                AnsiConsole.MarkupLine($"[bold green]Creating MVC resource '{name}' in '{projectDir}'...[/]");
-                try { await scaffoldingService.GenerateAsync(template, projectDir, variables); AnsiConsole.MarkupLine("[bold green]Done![/]"); }
-                catch (Exception ex) { AnsiConsole.WriteException(ex); }
+                if (projectDir == null)
+                {
+                    AnsiConsole.MarkupLine("[red]Error:[/] Could not find an MVC project (no 'Controllers' directory).");
+                    Environment.ExitCode = 1;
+                    return;
+                }
+
+                AnsiConsole.MarkupLine($"[bold green]Creating MVC resource '{name}' in '{ToDisplayPath(projectDir)}'...[/]");
+                try
+                {
+                    Report(await scaffoldingService.GenerateAsync(template, projectDir, variables, force));
+                }
+                catch (ScaffoldingException ex)
+                {
+                    AnsiConsole.MarkupLine($"[red]Error:[/] {Markup.Escape(ex.Message)}");
+                    Environment.ExitCode = 1;
+                }
+                catch (Exception ex)
+                {
+                    AnsiConsole.WriteException(ex);
+                    Environment.ExitCode = 1;
+                }
             }
             else if (context.Architecture == MTC.Models.Architecture.CleanArch)
             {
-                // Clean Arch Logic
                 var template = templateService.GetTemplate("CleanArchFeature");
-                if (template == null) { AnsiConsole.MarkupLine("[red]Error:[/] Template 'CleanArchFeature' not found."); return; }
-
-                // We need to inject into multiple projects (Domain, Application, API)
-                // ScaffoldingService generates relative to output dir.
-                // Our template structure mirrors the folders: Domain/Entities, Application/Features, API/Controllers
-                // So we can target the Solution Directory directly?
-                // No, the template has folders like "Domain/Entities".
-                // If we output to SolutionDirectory, it will try to create SolutionDirectory/Domain/Entities
-                // But the actual path might be SolutionDirectory/ProjectName.Domain/Entities
-                // This is tricky because project names vary.
-                
-                // Workaround: We need to find the actual paths for Domain, Application, API projects.
+                if (template == null)
+                {
+                    AnsiConsole.MarkupLine("[red]Error:[/] Template 'CleanArchFeature' not found.");
+                    Environment.ExitCode = 1;
+                    return;
+                }
+
+                // A Clean Architecture feature spans three projects. The template mirrors them
+                // as fixed "Domain"/"Application"/"API" folders, but the real projects are named
+                // after the solution (MyApp.Domain, MyApp.Application, ...). So we render into a
+                // temp directory and then copy each folder into the project it belongs to.
                 var domainDir = Directory.GetDirectories(context.SolutionDirectory, "*.Domain", SearchOption.AllDirectories).FirstOrDefault();
                 var appDir = Directory.GetDirectories(context.SolutionDirectory, "*.Application", SearchOption.AllDirectories).FirstOrDefault();
                 var apiDir = Directory.GetDirectories(context.SolutionDirectory, "*.API", SearchOption.AllDirectories).FirstOrDefault();
@@ -203,71 +266,76 @@ static async Task Main(string[] args)
                 if (domainDir == null || appDir == null || apiDir == null)
                 {
                     AnsiConsole.MarkupLine("[red]Error:[/] Could not find one or more Clean Architecture layers.");
+                    AnsiConsole.MarkupLine("Expected projects ending in [yellow].Domain[/], [yellow].Application[/] and [yellow].API[/].");
+                    Environment.ExitCode = 1;
                     return;
                 }
 
-                // We will generate piece by piece or adjust the template?
-                // Adjusting the template to match exact project names is hard.
-                // Better approach: The template has "Domain", "Application", "API" folders.
-                // We can generate into a temp folder and then move files? Or update ScaffoldingService?
-                
-                // Let's try to map the template folders to the actual project folders.
-                // Template: Domain/Entities/{{Name}}.cs -> Actual: MyProject.Domain/Entities/{{Name}}.cs
-                
-                // We can run the generator 3 times, pointing to each project, using partial templates?
-                // Or we can assume standard naming and generate into SolutionDir, but that risks mismatch if project folders are named "MyProject.Domain".
-                
-                // Let's assume standard CleanArch template structure:
-                // SolutionDir/
-                //   MyProject.Domain/
-                //   MyProject.Application/
-                //   MyProject.API/
-
-                // If we generate "Domain/Entities/..." into SolutionDir, we get "SolutionDir/Domain/Entities/..."
-                // We want "SolutionDir/MyProject.Domain/Entities/..."
-                
-                // Hack: We can pass the project folder names as variables to the template?
-                // But the template folder structure is static.
-                
-                // Alternative: Update ScaffoldingService to handle mapping? Too complex.
-                
-                // Simple solution for now:
-                // Generate into a temp folder, then move files to correct locations.
-                
                 var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
                 Directory.CreateDirectory(tempDir);
 
-                try 
+                try
                 {
-                    await scaffoldingService.GenerateAsync(template, tempDir, variables);
-                    
-                    // Move Domain
-                    var sourceDomain = Path.Combine(tempDir, "Domain");
-                    CopyFilesRecursively(sourceDomain, domainDir);
-
-                    // Move Application
-                    var sourceApp = Path.Combine(tempDir, "Application");
-                    CopyFilesRecursively(sourceApp, appDir);
-
-                    // Move API
-                    var sourceApi = Path.Combine(tempDir, "API");
-                    CopyFilesRecursively(sourceApi, apiDir);
-
-                    AnsiConsole.MarkupLine("[bold green]Done![/]");
+                    // The temp directory is empty, so this render never conflicts. The
+                    // files that matter are the ones we are about to copy on top of the
+                    // real projects, so that is where the check has to happen.
+                    await scaffoldingService.GenerateAsync(template, tempDir, variables, overwrite: true);
+
+                    var layers = new[]
+                    {
+                        (Source: Path.Combine(tempDir, "Domain"), Destination: domainDir),
+                        (Source: Path.Combine(tempDir, "Application"), Destination: appDir),
+                        (Source: Path.Combine(tempDir, "API"), Destination: apiDir)
+                    };
+
+                    var conflicts = layers
+                        .SelectMany(layer => FindCopyConflicts(layer.Source, layer.Destination))
+                        .ToList();
+
+                    if (conflicts.Count > 0 && !force)
+                    {
+                        ReportConflicts(conflicts);
+                        return;
+                    }
+
+                    var copied = layers
+                        .SelectMany(layer => CopyFilesRecursively(layer.Source, layer.Destination))
+                        .ToList();
+
+                    Report(ScaffoldResult.Written(copied, conflicts));
+                }
+                catch (ScaffoldingException ex)
+                {
+                    AnsiConsole.MarkupLine($"[red]Error:[/] {Markup.Escape(ex.Message)}");
+                    Environment.ExitCode = 1;
+                }
+                catch (Exception ex)
+                {
+                    AnsiConsole.WriteException(ex);
+                    Environment.ExitCode = 1;
+                }
+                finally
+                {
+                    Directory.Delete(tempDir, true);
                 }
-                catch (Exception ex) { AnsiConsole.WriteException(ex); }
-                finally { Directory.Delete(tempDir, true); }
             }
 
-        }, featureNameArg, fieldsOption);
+        }, featureNameArg, fieldsOption, featureForceOption);
 
         addCommand.AddCommand(addFeatureCommand);
 
-        // Add Value Object Command
-        var addValueObjectCommand = new Command("value-object", "Add a new Value Object");
-        addValueObjectCommand.AddArgument(featureNameArg);
-        addValueObjectCommand.AddOption(fieldsOption);
-        addValueObjectCommand.SetHandler(async (name, fields) =>
+        // 'add value-object' and 'add dto' follow the same shape: render a single-file
+        // template into whichever folder the detected architecture expects. They differ
+        // only in the template, the Clean Architecture project they belong to, and the
+        // folder/namespace suffix.
+        async Task AddSingleFileItemAsync(
+            string name,
+            string fields,
+            bool force,
+            string displayName,
+            string templateName,
+            string cleanArchProjectPattern,
+            string folderName)
         {
             var contextService = host.Services.GetRequiredService<IContextService>();
             var templateService = host.Services.GetRequiredService<ITemplateService>();
@@ -279,43 +347,63 @@ static async Task Main(string[] args)
 
             if (context.Architecture == MTC.Models.Architecture.Unknown)
             {
-                AnsiConsole.MarkupLine("[red]Error:[/] Unknown project architecture.");
+                AnsiConsole.MarkupLine("[red]Error:[/] Could not detect the project architecture.");
+                AnsiConsole.MarkupLine("Run [green]mtc debug-context[/] from inside your solution to see what MTC found.");
+                Environment.ExitCode = 1;
                 return;
             }
 
             var properties = fieldParser.Parse(fields);
-            var projectName = Path.GetFileNameWithoutExtension(context.SolutionPath) ?? "MyProject";
-            string targetNamespace = $"{projectName}.ValueObjects";
-            string targetDir = string.Empty;
+            var projectName = Path.GetFileNameWithoutExtension(context.SolutionPath);
+            if (string.IsNullOrEmpty(projectName))
+            {
+                projectName = "MyProject";
+            }
+
+            var targetNamespace = $"{projectName}.{folderName}";
+            var targetDir = string.Empty;
 
             if (context.Architecture == MTC.Models.Architecture.CleanArch)
             {
-                var domainDir = Directory.GetDirectories(context.SolutionDirectory, "*.Domain", SearchOption.AllDirectories).FirstOrDefault();
-                if (domainDir != null)
+                var layerDir = Directory
+                    .GetDirectories(context.SolutionDirectory, cleanArchProjectPattern, SearchOption.AllDirectories)
+                    .FirstOrDefault();
+
+                if (layerDir != null)
                 {
-                    targetDir = Path.Combine(domainDir, "ValueObjects");
-                    targetNamespace = $"{new DirectoryInfo(domainDir).Name}.ValueObjects";
+                    targetDir = Path.Combine(layerDir, folderName);
+                    targetNamespace = $"{new DirectoryInfo(layerDir).Name}.{folderName}";
                 }
             }
             else if (context.Architecture == MTC.Models.Architecture.MvcMonolith)
             {
-                 var projectDir = Directory.GetDirectories(context.SolutionDirectory).FirstOrDefault(d => Directory.Exists(Path.Combine(d, "Controllers")));
-                 if (projectDir != null)
-                 {
-                     targetDir = Path.Combine(projectDir, "Models", "ValueObjects");
-                     targetNamespace = $"{new DirectoryInfo(projectDir).Name}.Models.ValueObjects";
-                 }
+                var projectDir = Directory.GetDirectories(context.SolutionDirectory)
+                    .FirstOrDefault(d => Directory.Exists(Path.Combine(d, "Controllers")));
+
+                if (projectDir != null)
+                {
+                    targetDir = Path.Combine(projectDir, "Models", folderName);
+                    targetNamespace = $"{new DirectoryInfo(projectDir).Name}.Models.{folderName}";
+                }
             }
-            else // Vertical Slice or other
+            else // Vertical Slice or other: drop it next to where the user is standing.
             {
-                // Default to current directory or Features/Shared
-                targetDir = Path.Combine(currentPath, "ValueObjects");
+                targetDir = Path.Combine(currentPath, folderName);
             }
 
             if (string.IsNullOrEmpty(targetDir))
             {
-                 AnsiConsole.MarkupLine("[red]Error:[/] Could not determine target directory.");
-                 return;
+                AnsiConsole.MarkupLine($"[red]Error:[/] Could not find a [yellow]{cleanArchProjectPattern}[/] project to place the {displayName} in.");
+                Environment.ExitCode = 1;
+                return;
+            }
+
+            var template = templateService.GetTemplate(templateName);
+            if (template == null)
+            {
+                AnsiConsole.MarkupLine($"[red]Error:[/] Template '{templateName}' not found.");
+                Environment.ExitCode = 1;
+                return;
             }
 
             var variables = new Dictionary<string, object>
@@ -325,86 +413,51 @@ static async Task Main(string[] args)
                 { "Namespace", targetNamespace }
             };
 
-            var template = templateService.GetTemplate("ValueObject");
-            if (template == null) { AnsiConsole.MarkupLine("[red]Error:[/] Template 'ValueObject' not found."); return; }
-
-            AnsiConsole.MarkupLine($"[bold green]Creating Value Object '{name}' in '{targetDir}'...[/]");
-            try { await scaffoldingService.GenerateAsync(template, targetDir, variables); AnsiConsole.MarkupLine("[bold green]Done![/]"); }
-            catch (Exception ex) { AnsiConsole.WriteException(ex); }
-
-        }, featureNameArg, fieldsOption);
-        addCommand.AddCommand(addValueObjectCommand);
-
-        // Add DTO Command
-        var addDtoCommand = new Command("dto", "Add a new DTO");
-        addDtoCommand.AddArgument(featureNameArg);
-        addDtoCommand.AddOption(fieldsOption);
-        addDtoCommand.SetHandler(async (name, fields) =>
-        {
-            var contextService = host.Services.GetRequiredService<IContextService>();
-            var templateService = host.Services.GetRequiredService<ITemplateService>();
-            var scaffoldingService = host.Services.GetRequiredService<IScaffoldingService>();
-            var fieldParser = host.Services.GetRequiredService<IFieldParser>();
-
-            var currentPath = Directory.GetCurrentDirectory();
-            var context = contextService.Analyze(currentPath);
-
-            if (context.Architecture == MTC.Models.Architecture.Unknown)
-            {
-                AnsiConsole.MarkupLine("[red]Error:[/] Unknown project architecture.");
-                return;
-            }
-
-            var properties = fieldParser.Parse(fields);
-            var projectName = Path.GetFileNameWithoutExtension(context.SolutionPath) ?? "MyProject";
-            string targetNamespace = $"{projectName}.DTOs";
-            string targetDir = string.Empty;
-
-            if (context.Architecture == MTC.Models.Architecture.CleanArch)
-            {
-                var appDir = Directory.GetDirectories(context.SolutionDirectory, "*.Application", SearchOption.AllDirectories).FirstOrDefault();
-                if (appDir != null)
-                {
-                    targetDir = Path.Combine(appDir, "DTOs");
-                    targetNamespace = $"{new DirectoryInfo(appDir).Name}.DTOs";
-                }
-            }
-            else if (context.Architecture == MTC.Models.Architecture.MvcMonolith)
+            AnsiConsole.MarkupLine($"[bold green]Creating {displayName} '{name}' in '{ToDisplayPath(targetDir)}'...[/]");
+            try
             {
-                 var projectDir = Directory.GetDirectories(context.SolutionDirectory).FirstOrDefault(d => Directory.Exists(Path.Combine(d, "Controllers")));
-                 if (projectDir != null)
-                 {
-                     targetDir = Path.Combine(projectDir, "Models", "DTOs");
-                     targetNamespace = $"{new DirectoryInfo(projectDir).Name}.Models.DTOs";
-                 }
+                Report(await scaffoldingService.GenerateAsync(template, targetDir, variables, force));
             }
-            else // Vertical Slice or other
+            catch (ScaffoldingException ex)
             {
-                targetDir = Path.Combine(currentPath, "DTOs");
+                AnsiConsole.MarkupLine($"[red]Error:[/] {Markup.Escape(ex.Message)}");
+                Environment.ExitCode = 1;
             }
-
-            if (string.IsNullOrEmpty(targetDir))
+            catch (Exception ex)
             {
-                 AnsiConsole.MarkupLine("[red]Error:[/] Could not determine target directory.");
-                 return;
+                AnsiConsole.WriteException(ex);
+                Environment.ExitCode = 1;
             }
+        }
 
-            var variables = new Dictionary<string, object>
-            {
-                { "Name", name },
-                { "Properties", properties },
-                { "Namespace", targetNamespace }
-            };
-
-            var template = templateService.GetTemplate("Dto");
-            if (template == null) { AnsiConsole.MarkupLine("[red]Error:[/] Template 'Dto' not found."); return; }
-
-            AnsiConsole.MarkupLine($"[bold green]Creating DTO '{name}' in '{targetDir}'...[/]");
-            try { await scaffoldingService.GenerateAsync(template, targetDir, variables); AnsiConsole.MarkupLine("[bold green]Done![/]"); }
-            catch (Exception ex) { AnsiConsole.WriteException(ex); }
+        // 'add value-object' command
+        var addValueObjectCommand = new Command("value-object", "Add a new Value Object");
+        var valueObjectNameArg = NameArgument("The name of the Value Object");
+        var valueObjectFieldsOption = FieldsOption();
+        var valueObjectForceOption = ForceOption();
+        addValueObjectCommand.AddArgument(valueObjectNameArg);
+        addValueObjectCommand.AddOption(valueObjectFieldsOption);
+        addValueObjectCommand.AddOption(valueObjectForceOption);
+        addValueObjectCommand.SetHandler(
+            async (string name, string fields, bool force) =>
+                await AddSingleFileItemAsync(name, fields, force, "Value Object", "ValueObject", "*.Domain", "ValueObjects"),
+            valueObjectNameArg, valueObjectFieldsOption, valueObjectForceOption);
+        addCommand.AddCommand(addValueObjectCommand);
 
-        }, featureNameArg, fieldsOption);
+        // 'add dto' command
+        var addDtoCommand = new Command("dto", "Add a new DTO");
+        var dtoNameArg = NameArgument("The name of the DTO");
+        var dtoFieldsOption = FieldsOption();
+        var dtoForceOption = ForceOption();
+        addDtoCommand.AddArgument(dtoNameArg);
+        addDtoCommand.AddOption(dtoFieldsOption);
+        addDtoCommand.AddOption(dtoForceOption);
+        addDtoCommand.SetHandler(
+            async (string name, string fields, bool force) =>
+                await AddSingleFileItemAsync(name, fields, force, "DTO", "Dto", "*.Application", "DTOs"),
+            dtoNameArg, dtoFieldsOption, dtoForceOption);
         addCommand.AddCommand(addDtoCommand);
+
         rootCommand.AddCommand(addCommand);
 
         // Config Command
@@ -514,18 +567,93 @@ static async Task Main(string[] args)
         await parser.InvokeAsync(args);
     }
 
-    private static void CopyFilesRecursively(string sourcePath, string targetPath)
+    /// <summary>
+    /// Prints the outcome of a scaffolding run and sets the exit code.
+    /// Returns false when the run was blocked by existing files.
+    /// </summary>
+    private static bool Report(ScaffoldResult result)
     {
-        // Now Create all of the directories
-        foreach (string dirPath in Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories))
+        if (!result.Succeeded)
         {
-            Directory.CreateDirectory(dirPath.Replace(sourcePath, targetPath));
+            ReportConflicts(result.ConflictingFiles);
+            return false;
         }
 
-        // Copy all the files & Replaces any files with the same name
-        foreach (string newPath in Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories))
+        foreach (var path in result.CreatedFiles)
         {
-            File.Copy(newPath, newPath.Replace(sourcePath, targetPath), true);
+            var replaced = result.OverwrittenFiles.Contains(path);
+            var label = replaced ? "[yellow]Replaced[/]" : "[grey]Created[/] ";
+            AnsiConsole.MarkupLine($"  {label} {Markup.Escape(ToDisplayPath(path))}");
         }
+
+        AnsiConsole.MarkupLine("[bold green]Done![/]");
+        return true;
     }
+
+    private static void ReportConflicts(IReadOnlyList<string> conflicts)
+    {
+        AnsiConsole.MarkupLine(
+            $"[red]Error:[/] {conflicts.Count} file(s) already exist and would be overwritten:");
+
+        foreach (var path in conflicts)
+        {
+            AnsiConsole.MarkupLine($"  [yellow]{Markup.Escape(ToDisplayPath(path))}[/]");
+        }
+
+        AnsiConsole.MarkupLine("Nothing was written. Re-run with [green]--force[/] to replace them.");
+        Environment.ExitCode = 1;
+    }
+
+    /// <summary>Shortens a path relative to the working directory when that reads better.</summary>
+    private static string ToDisplayPath(string fullPath)
+    {
+        var relative = Path.GetRelativePath(Directory.GetCurrentDirectory(), fullPath);
+        return relative.StartsWith("..", StringComparison.Ordinal) ? fullPath : relative;
+    }
+
+    /// <summary>Files under <paramref name="sourcePath"/> that already exist at the destination.</summary>
+    private static List<string> FindCopyConflicts(string sourcePath, string targetPath)
+    {
+        if (!Directory.Exists(sourcePath))
+        {
+            return new List<string>();
+        }
+
+        return Directory.GetFiles(sourcePath, "*", SearchOption.AllDirectories)
+            .Select(file => RebasePath(file, sourcePath, targetPath))
+            .Where(File.Exists)
+            .ToList();
+    }
+
+    private static List<string> CopyFilesRecursively(string sourcePath, string targetPath)
+    {
+        var copied = new List<string>();
+        if (!Directory.Exists(sourcePath))
+        {
+            return copied;
+        }
+
+        foreach (var file in Directory.GetFiles(sourcePath, "*", SearchOption.AllDirectories))
+        {
+            var destination = RebasePath(file, sourcePath, targetPath);
+            var directory = Path.GetDirectoryName(destination);
+            if (!string.IsNullOrEmpty(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            File.Copy(file, destination, true);
+            copied.Add(destination);
+        }
+
+        return copied;
+    }
+
+    /// <summary>
+    /// Moves a file path from one directory tree onto another. Uses a relative path
+    /// rather than string replacement, which misfired when the source directory name
+    /// appeared again further down the path.
+    /// </summary>
+    private static string RebasePath(string file, string sourceRoot, string targetRoot) =>
+        Path.Combine(targetRoot, Path.GetRelativePath(sourceRoot, file));
 }
diff --git a/MTC/Services/FieldParser.cs b/MTC/Services/FieldParser.cs
index e1771b1..d5a7d3d 100644
--- a/MTC/Services/FieldParser.cs
+++ b/MTC/Services/FieldParser.cs
@@ -4,6 +4,17 @@ namespace MTC.Services;
 
 public class FieldParser : IFieldParser
 {
+    /// <summary>
+    /// Types that never need the <c>required</c> modifier. Anything not listed
+    /// here (including user-supplied types) is treated as a reference type,
+    /// which is the safe default: <c>required</c> is valid on value types too.
+    /// </summary>
+    private static readonly HashSet<string> ValueTypes = new(StringComparer.Ordinal)
+    {
+        "int", "long", "short", "byte", "float", "double", "decimal",
+        "bool", "char", "DateTime", "DateOnly", "TimeOnly", "Guid"
+    };
+
     public List<Property> Parse(string input)
     {
         var properties = new List<Property>();
@@ -18,10 +29,12 @@ public List<Property> Parse(string input)
             var parts = field.Split(':');
             if (parts.Length == 2)
             {
+                var mappedType = MapType(parts[1]);
                 properties.Add(new Property
                 {
                     Name = parts[0],
-                    Type = MapType(parts[1])
+                    Type = mappedType,
+                    IsValueType = ValueTypes.Contains(mappedType)
                 });
             }
         }
@@ -29,17 +42,25 @@ public List<Property> Parse(string input)
         return properties;
     }
 
-    private string MapType(string type)
+    private static string MapType(string type)
     {
-        return type.ToLower() switch
+        return type.ToLowerInvariant() switch
         {
             "string" => "string",
             "int" => "int",
-            "bool" => "bool",
+            "long" => "long",
+            "short" => "short",
+            "byte" => "byte",
+            "float" => "float",
+            "double" => "double",
             "decimal" => "decimal",
+            "bool" => "bool",
+            "char" => "char",
             "datetime" => "DateTime",
+            "dateonly" => "DateOnly",
+            "timeonly" => "TimeOnly",
             "guid" => "Guid",
-            _ => type // Fallback to provided type
+            _ => type // Fallback: assume the user named a type from their own project
         };
     }
 }
diff --git a/MTC/Services/IScaffoldingService.cs b/MTC/Services/IScaffoldingService.cs
index f03d810..f626e9b 100644
--- a/MTC/Services/IScaffoldingService.cs
+++ b/MTC/Services/IScaffoldingService.cs
@@ -4,5 +4,14 @@ namespace MTC.Services;
 
 public interface IScaffoldingService
 {
-    Task GenerateAsync(Template template, string targetDirectory, Dictionary<string, object> variables);
+    /// <summary>
+    /// Renders a template into <paramref name="targetDirectory"/>. Nothing is written
+    /// unless every file can be written: if any target already exists and
+    /// <paramref name="overwrite"/> is false, the run is reported as blocked instead.
+    /// </summary>
+    Task<ScaffoldResult> GenerateAsync(
+        Template template,
+        string targetDirectory,
+        Dictionary<string, object> variables,
+        bool overwrite = false);
 }
diff --git a/MTC/Services/ScaffoldingException.cs b/MTC/Services/ScaffoldingException.cs
new file mode 100644
index 0000000..034f9ae
--- /dev/null
+++ b/MTC/Services/ScaffoldingException.cs
@@ -0,0 +1,13 @@
+namespace MTC.Services;
+
+/// <summary>
+/// Raised when a template cannot be generated for a reason the user can act on,
+/// such as a name that would write outside the output directory. These surface as
+/// a plain error message rather than a stack trace.
+/// </summary>
+public class ScaffoldingException : Exception
+{
+    public ScaffoldingException(string message) : base(message)
+    {
+    }
+}
diff --git a/MTC/Services/ScaffoldingService.cs b/MTC/Services/ScaffoldingService.cs
index c25c1c0..302c12e 100644
--- a/MTC/Services/ScaffoldingService.cs
+++ b/MTC/Services/ScaffoldingService.cs
@@ -1,5 +1,4 @@
 using MTC.Models;
-using Spectre.Console;
 
 namespace MTC.Services;
 
@@ -12,23 +11,50 @@ public ScaffoldingService(ITemplateRenderer renderer)
         _renderer = renderer;
     }
 
-    public async Task GenerateAsync(Template template, string targetDirectory, Dictionary<string, object> variables)
+    public async Task<ScaffoldResult> GenerateAsync(
+        Template template,
+        string targetDirectory,
+        Dictionary<string, object> variables,
+        bool overwrite = false)
     {
-        if (!Directory.Exists(targetDirectory))
+        var root = Path.GetFullPath(targetDirectory);
+
+        // Everything is planned before anything is written, so a conflict leaves the
+        // target untouched instead of half-generated.
+        var plan = new List<PlannedFile>();
+        await PlanDirectoryAsync(new DirectoryInfo(template.RootPath), root, root, variables, plan);
+
+        var conflicts = plan
+            .Where(file => File.Exists(file.TargetPath))
+            .Select(file => file.TargetPath)
+            .ToList();
+
+        if (conflicts.Count > 0 && !overwrite)
         {
-            Directory.CreateDirectory(targetDirectory);
+            return ScaffoldResult.BlockedBy(conflicts);
+        }
+
+        foreach (var file in plan)
+        {
+            var directory = Path.GetDirectoryName(file.TargetPath);
+            if (!string.IsNullOrEmpty(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            await File.WriteAllTextAsync(file.TargetPath, file.Content);
         }
 
-        var templateFiles = Directory.GetFiles(template.RootPath, "*", SearchOption.AllDirectories);
-        Console.WriteLine($"[Debug] Found {templateFiles.Length} files in {template.RootPath}");
-        
-        var sourceDir = new DirectoryInfo(template.RootPath);
-        await ProcessDirectoryAsync(sourceDir, targetDirectory, variables);
+        return ScaffoldResult.Written(plan.Select(file => file.TargetPath).ToList(), conflicts);
     }
 
-    private async Task ProcessDirectoryAsync(DirectoryInfo sourceDir, string targetDir, Dictionary<string, object> variables)
+    private async Task PlanDirectoryAsync(
+        DirectoryInfo sourceDir,
+        string targetDir,
+        string root,
+        Dictionary<string, object> variables,
+        List<PlannedFile> plan)
     {
-        // Copy files
         foreach (var file in sourceDir.GetFiles())
         {
             if (file.Name.Equals("manifest.json", StringComparison.OrdinalIgnoreCase))
@@ -36,32 +62,40 @@ private async Task ProcessDirectoryAsync(DirectoryInfo sourceDir, string targetD
                 continue;
             }
 
-            var targetFileName = _renderer.Render(file.Name, variables);
-            var targetFilePath = Path.Combine(targetDir, targetFileName);
+            var targetPath = ResolveWithinRoot(targetDir, _renderer.Render(file.Name, variables), root);
 
             // TODO: Add binary file check to avoid rendering binaries
-            // For now, we assume everything is text or we try to render it. 
-            // If it fails or corrupts, we'll need to add a binary check.
-            
             var content = await File.ReadAllTextAsync(file.FullName);
-            var renderedContent = _renderer.Render(content, variables);
-
-            await File.WriteAllTextAsync(targetFilePath, renderedContent);
-            AnsiConsole.MarkupLine($"[grey]Created file:[/] {targetFilePath}");
+            plan.Add(new PlannedFile(targetPath, _renderer.Render(content, variables)));
         }
 
-        // Recursive copy directories
         foreach (var subDir in sourceDir.GetDirectories())
         {
-            var targetSubDirName = _renderer.Render(subDir.Name, variables);
-            var targetSubDirPath = Path.Combine(targetDir, targetSubDirName);
+            var targetSubDir = ResolveWithinRoot(targetDir, _renderer.Render(subDir.Name, variables), root);
+            await PlanDirectoryAsync(subDir, targetSubDir, root, variables, plan);
+        }
+    }
 
-            if (!Directory.Exists(targetSubDirPath))
-            {
-                Directory.CreateDirectory(targetSubDirPath);
-            }
+    /// <summary>
+    /// Combines a rendered name onto a directory and verifies the result stays under
+    /// <paramref name="root"/>. Names come from user input, so a value like "../.."
+    /// must not be able to write outside the output directory.
+    /// </summary>
+    private static string ResolveWithinRoot(string directory, string renderedName, string root)
+    {
+        var combined = Path.GetFullPath(Path.Combine(directory, renderedName));
+        var boundary = root.EndsWith(Path.DirectorySeparatorChar)
+            ? root
+            : root + Path.DirectorySeparatorChar;
 
-            await ProcessDirectoryAsync(subDir, targetSubDirPath, variables);
+        if (combined != root && !combined.StartsWith(boundary, StringComparison.Ordinal))
+        {
+            throw new ScaffoldingException(
+                $"Refusing to write outside the output directory: '{renderedName}' resolves to '{combined}'.");
         }
+
+        return combined;
     }
+
+    private sealed record PlannedFile(string TargetPath, string Content);
 }
diff --git a/README.md b/README.md
index 9edbcb0..a10ff95 100644
--- a/README.md
+++ b/README.md
@@ -1,139 +1,222 @@
-# MTC - Modular Template CLI
+# MTC — Modular Template CLI
 
-MTC is a powerful, architecture-aware CLI tool for scaffolding .NET projects. It supports **Clean Architecture**, **MVC Monolith**, and **Vertical Slice** patterns, allowing you to generate projects, features, value objects, and DTOs with ease.
+Scaffolding for .NET that understands the project you're already in.
 
-## Features
+`dotnet new` creates projects from scratch. MTC does that too, but its real job starts
+afterwards: run `mtc add feature Product` anywhere inside your solution and MTC detects
+whether you're in **Clean Architecture**, **MVC** or **Vertical Slice**, then writes each
+generated file into the layer where it belongs.
 
-- **Project Scaffolding**: Create new projects using pre-defined templates (`ConsoleApp`, `MvcMonolith`, `CleanArch`, `VerticalSlice`).
-- **Architecture Awareness**: Automatically detects the project structure (MVC, Clean Arch, Vertical Slice) and places generated files in the correct layers/folders.
-- **Feature Generation**: Generate full feature slices (Controller, Command/Query, Models) with a single command.
-- **Productivity Tools**: Quickly add Value Objects and DTOs.
-- **User Configuration**: Persist global preferences (e.g., Author name).
-- **Cross-Platform**: Runs on Windows, Linux, and macOS.
-
-## Installation
-
-### Arch Linux (AUR)
 ```bash
-yay -S mtc-bin
-```
+cd MyShop                       # a Clean Architecture solution
+mtc add feature Product --fields "Name:string Price:decimal"
 
-### .NET Tool (Global)
-```bash
-dotnet tool install -g MTC
+# → MyShop.Domain/Entities/Product.cs
+# → MyShop.Application/Features/Products/Commands/CreateProduct/...
+# → MyShop.API/Controllers/ProductsController.cs
 ```
 
-### Debian/Ubuntu (.deb)
-Download the latest `.deb` release and run:
-```bash
-sudo dpkg -i mtc_1.0.0_amd64.deb
-```
+No config file, no flags telling it what your architecture is. It looks at your solution
+and figures it out.
+
+---
+
+## Install
 
-### Manual (Binary)
-Download the binary for your OS from [Releases](https://github.com/JuansesDev/MTC/releases).
+Pick whichever fits your setup.
 
-**Windows**:
-1. Download `mtc-win-x64-1.0.0.tar.gz`.
-2. Extract the contents (Windows 10/11 supports tar.gz natively, or use 7-Zip).
-3. Add the extracted folder to your System PATH.
+| Method | Command |
+|---|---|
+| .NET tool (any OS) | `dotnet tool install -g MTC` |
+| Arch Linux (AUR) | `yay -S mtc-bin` |
+| Debian / Ubuntu | download the `.deb` from [Releases](https://github.com/JuansesDev/MTC/releases), then `sudo dpkg -i mtc_<version>_amd64.deb` |
+| Manual binary | download the `.tar.gz` for your OS from [Releases](https://github.com/JuansesDev/MTC/releases) |
 
-**Linux/macOS**:
-1. Download the `.tar.gz` for your OS.
-2. Extract and move the binary to `/usr/local/bin` or add to PATH.
+**Manual install details**
 
-## Usage
+- **Linux / macOS** — extract the archive, move the `mtc` binary somewhere on your `PATH`
+  (`/usr/local/bin` works), and keep the `templates/` folder next to it.
+- **Windows** — extract the archive (Windows 10/11 handles `.tar.gz` natively) and add the
+  extracted folder to your `PATH`.
+
+Requires the [.NET 10 SDK](https://dotnet.microsoft.com/download) if you install as a .NET
+tool. The standalone binaries are self-contained and need nothing.
+
+---
+
+## Quick start
+
+Create a project, then grow it.
 
-### List Available Templates
 ```bash
-mtc list
+# 1. Make a folder and scaffold the solution into it
+mkdir MyShop && cd MyShop
+mtc new CleanArch MyShop
+
+# 2. Add a feature — MTC places the files for you
+mtc add feature Product --fields "Name:string Price:decimal Stock:int"
 ```
 
-### Create a New Project
-```bash
-# Console Application
-mtc new ConsoleApp MyApp
+That's the whole loop. Step 2 is the one you'll run over and over.
+
+> `mtc new` writes into the **current directory** (or `--output`), it does not create a
+> containing folder for you. Make the folder first, as above.
 
-# MVC Monolith
-mtc new MvcMonolith MyWebApp
+---
 
-# Clean Architecture
-mtc new CleanArch MyCleanApp
+## Commands
 
-# Vertical Slice Architecture
-mtc new VerticalSlice MyApiApp
+### `mtc new <template> [name]`
+
+Creates a new project from a template.
+
+```bash
+mtc new ConsoleApp    MyApp
+mtc new MvcMonolith   MyWebApp
+mtc new CleanArch     MyShop
+mtc new VerticalSlice MyApi
 ```
 
-### Add Features to Existing Projects
-MTC automatically detects your project architecture and generates the appropriate files.
+| Option | Description |
+|---|---|
+| `[name]` | Project name. Defaults to the output directory name. |
+| `-o`, `--output` | Where to create it. Defaults to the current directory. |
+| `-n`, `--name` | Same as the positional `[name]`. Takes precedence if both are given. |
+| `--force` | Overwrite files that already exist. |
+
+### `mtc add feature <name> [--fields "..."]`
+
+Generates a full feature — entity, commands/queries, and controller — placed according to
+the detected architecture.
 
-#### Add a Feature (CRUD)
 ```bash
-# Generates Controller, Commands/Queries, and Models based on your architecture
 mtc add feature Product --fields "Name:string Price:decimal Stock:int"
 ```
 
-#### Add a Value Object
+| Architecture | Where the files land |
+|---|---|
+| Clean Architecture | split across `*.Domain`, `*.Application` and `*.API` |
+| Vertical Slice | a new folder under `Features/` |
+| MVC Monolith | `Controllers/`, `Models/` and `Views/` |
+
+### `mtc add value-object <name> [--fields "..."]`
+
 ```bash
 mtc add value-object Money --fields "Amount:decimal Currency:string"
-mtc add value-object Email --fields "Value:string"
 ```
 
-#### Add a DTO
+Goes to `*.Domain/ValueObjects` in Clean Architecture, `Models/ValueObjects` in MVC, and
+`./ValueObjects` otherwise.
+
+### `mtc add dto <name> [--fields "..."]`
+
 ```bash
 mtc add dto UserDto --fields "Username:string Email:string Age:int"
-mtc add dto ProductDto --fields "Id:guid Name:string Price:decimal"
 ```
 
-### Configuration Commands
+Goes to `*.Application/DTOs` in Clean Architecture, `Models/DTOs` in MVC, and `./DTOs`
+otherwise.
+
+### `mtc list`
+
+Lists every available template with its description, author and version.
+
+### `mtc config <set|get|list>`
+
+Persists preferences in `~/.mtc/config.json`.
+
 ```bash
-# Set a configuration value
 mtc config set Author "Your Name"
-mtc config set Company "Your Company"
-
-# Get a configuration value
 mtc config get Author
-
-# List all configuration
 mtc config list
 ```
 
-### Debug Commands
+### `mtc debug-context`
+
+Shows what MTC detected — solution path and architecture. Run this first whenever a
+generate command says it can't figure out your project.
+
 ```bash
-# Show detected project context (architecture, root path, etc.)
 mtc debug-context
 ```
 
-### Field Types
-When using `--fields`, you can use these types:
-- `string`, `int`, `decimal`, `bool`, `datetime`, `guid`
-- Example: `"Name:string Price:decimal IsActive:bool CreatedAt:datetime"`
+---
 
-## Development
+## MTC never overwrites your work
 
-### Build
-```bash
-dotnet build
-```
+Every generate command checks its targets first. If a file it would write already
+exists, MTC writes **nothing at all** and tells you what got in the way:
 
-### Test
-```bash
-dotnet test
 ```
-
-### Publish Binaries
-```bash
-./publish.sh
+$ mtc add feature Product --fields "Name:string Price:decimal"
+Error: 4 file(s) already exist and would be overwritten:
+  MyShop.Domain/Entities/Product.cs
+  MyShop.Application/Features/Products/Queries/GetProducts/GetProductsQuery.cs
+  MyShop.Application/Features/Products/Commands/CreateProduct/CreateProductCommand.cs
+  MyShop.API/Controllers/ProductsController.cs
+Nothing was written. Re-run with --force to replace them.
 ```
 
-### Publish to AUR (Maintainers only)
+It exits with code 1, so scripts and CI notice. Pass `--force` when you do want the
+files regenerated. Generation is all-or-nothing — a conflict never leaves you with a
+half-written feature.
+
+## Field types
+
+`--fields` takes a space-separated list of `Name:type` pairs:
+
 ```bash
-./publish_aur.sh
+--fields "Name:string Price:decimal IsActive:bool CreatedAt:datetime Id:guid"
 ```
 
-### Build Debian Package (Maintainers only)
+| Alias | Generates |
+|---|---|
+| `string` | `string` |
+| `int`, `long`, `short`, `byte` | `int`, `long`, `short`, `byte` |
+| `float`, `double`, `decimal` | `float`, `double`, `decimal` |
+| `bool` | `bool` |
+| `char` | `char` |
+| `datetime` | `DateTime` |
+| `dateonly` | `DateOnly` |
+| `timeonly` | `TimeOnly` |
+| `guid` | `Guid` |
+
+Anything else is passed through unchanged, so `Status:OrderStatus` works if that type
+exists in your project.
+
+Reference-typed properties are generated with the `required` modifier, so the code MTC
+writes compiles clean under `<Nullable>enable</Nullable>`.
+
+---
+
+## How detection works
+
+MTC walks up from your current directory until it finds a `.sln`, then inspects the
+projects around it:
+
+- projects ending in `.Domain`, `.Application`, `.Infrastructure` **and** `.API` → **Clean Architecture**
+- a `Features/` folder → **Vertical Slice**
+- a project holding `Controllers/`, `Views/` and `Models/` → **MVC Monolith**
+
+If none match, MTC stops and tells you rather than guessing. `mtc debug-context` shows
+exactly what it saw.
+
+---
+
+## Development
+
 ```bash
-./publish_deb.sh
+dotnet build
+dotnet test
 ```
 
+Integration tests drive the compiled binary, so build before testing.
+
+Maintainer scripts: `./publish.sh` (cross-platform binaries), `./publish_aur.sh`,
+`./publish_deb.sh`.
+
+---
+
 ## License
-MIT
+
+MIT — see [LICENSE](LICENSE).
diff --git a/Templates/CleanArch/{{Name}}.API/{{Name}}.API.csproj b/Templates/CleanArch/{{Name}}.API/{{Name}}.API.csproj
index f0cb609..6bca1cf 100644
--- a/Templates/CleanArch/{{Name}}.API/{{Name}}.API.csproj
+++ b/Templates/CleanArch/{{Name}}.API/{{Name}}.API.csproj
@@ -1,13 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.10" />
+    <!-- Pinned above the version AspNetCore.OpenApi pulls in transitively, which
+         carries a known advisory (GHSA-v5pm-xwqc-g5wc). -->
+    <PackageReference Include="Microsoft.OpenApi" Version="2.11.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Templates/CleanArch/{{Name}}.Application/{{Name}}.Application.csproj b/Templates/CleanArch/{{Name}}.Application/{{Name}}.Application.csproj
index 47bb59a..db9d9ba 100644
--- a/Templates/CleanArch/{{Name}}.Application/{{Name}}.Application.csproj
+++ b/Templates/CleanArch/{{Name}}.Application/{{Name}}.Application.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -11,8 +11,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.10" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.10" />
     <PackageReference Include="MediatR" Version="12.4.1" />
   </ItemGroup>
 
diff --git a/Templates/CleanArch/{{Name}}.Domain/{{Name}}.Domain.csproj b/Templates/CleanArch/{{Name}}.Domain/{{Name}}.Domain.csproj
index 0d2df0d..9ed914b 100644
--- a/Templates/CleanArch/{{Name}}.Domain/{{Name}}.Domain.csproj
+++ b/Templates/CleanArch/{{Name}}.Domain/{{Name}}.Domain.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
diff --git a/Templates/CleanArch/{{Name}}.Infrastructure/{{Name}}.Infrastructure.csproj b/Templates/CleanArch/{{Name}}.Infrastructure/{{Name}}.Infrastructure.csproj
index a3e1665..c39b006 100644
--- a/Templates/CleanArch/{{Name}}.Infrastructure/{{Name}}.Infrastructure.csproj
+++ b/Templates/CleanArch/{{Name}}.Infrastructure/{{Name}}.Infrastructure.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.10" />
   </ItemGroup>
 
 </Project>
diff --git a/Templates/Common/Dto/{{Name}}.cs b/Templates/Common/Dto/{{Name}}.cs
index fbfbe2b..df120f1 100644
--- a/Templates/Common/Dto/{{Name}}.cs
+++ b/Templates/Common/Dto/{{Name}}.cs
@@ -2,7 +2,7 @@ namespace {{Namespace}};
 
 public class {{Name}}
 {
-    {{ for prop in Properties }}
-    public {{ prop.Type }} {{ prop.Name }} { get; set; }
-    {{ end }}
+{{~ for prop in Properties ~}}
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; set; }
+{{~ end ~}}
 }
diff --git a/Templates/Common/ValueObject/{{Name}}.cs b/Templates/Common/ValueObject/{{Name}}.cs
index 327f8ad..35e8ec6 100644
--- a/Templates/Common/ValueObject/{{Name}}.cs
+++ b/Templates/Common/ValueObject/{{Name}}.cs
@@ -2,7 +2,7 @@ namespace {{Namespace}};
 
 public record {{Name}}
 {
-    {{ for prop in Properties }}
-    public {{ prop.Type }} {{ prop.Name }} { get; init; }
-    {{ end }}
+{{~ for prop in Properties ~}}
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; init; }
+{{~ end ~}}
 }
diff --git a/Templates/ConsoleApp/{{Name}}/{{Name}}.csproj b/Templates/ConsoleApp/{{Name}}/{{Name}}.csproj
index 694035b..dfb40ca 100644
--- a/Templates/ConsoleApp/{{Name}}/{{Name}}.csproj
+++ b/Templates/ConsoleApp/{{Name}}/{{Name}}.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
diff --git a/Templates/Features/CleanArch/Application/Features/{{Name}}s/Commands/Create{{Name}}/Create{{Name}}Command.cs b/Templates/Features/CleanArch/Application/Features/{{Name}}s/Commands/Create{{Name}}/Create{{Name}}Command.cs
index 572d504..47dc411 100644
--- a/Templates/Features/CleanArch/Application/Features/{{Name}}s/Commands/Create{{Name}}/Create{{Name}}Command.cs
+++ b/Templates/Features/CleanArch/Application/Features/{{Name}}s/Commands/Create{{Name}}/Create{{Name}}Command.cs
@@ -6,9 +6,9 @@ namespace {{ProjectName}}.Application.Features.{{Name}}s.Commands.Create{{Name}}
 
 public record Create{{Name}}Command : IRequest<int>
 {
-    {{ for prop in Properties }}
-    public {{ prop.Type }} {{ prop.Name }} { get; init; }
-    {{ end }}
+{{~ for prop in Properties ~}}
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; init; }
+{{~ end ~}}
 }
 
 public class Create{{Name}}CommandHandler : IRequestHandler<Create{{Name}}Command, int>
@@ -24,9 +24,9 @@ public async Task<int> Handle(Create{{Name}}Command request, CancellationToken c
     {
         var entity = new {{Name}}
         {
-            {{ for prop in Properties }}
+{{~ for prop in Properties ~}}
             {{ prop.Name }} = request.{{ prop.Name }},
-            {{ end }}
+{{~ end ~}}
         };
 
         _context.Set<{{Name}}>().Add(entity);
diff --git a/Templates/Features/CleanArch/Domain/Entities/{{Name}}.cs b/Templates/Features/CleanArch/Domain/Entities/{{Name}}.cs
index d205dd6..cedf556 100644
--- a/Templates/Features/CleanArch/Domain/Entities/{{Name}}.cs
+++ b/Templates/Features/CleanArch/Domain/Entities/{{Name}}.cs
@@ -4,7 +4,7 @@ namespace {{ProjectName}}.Domain.Entities;
 
 public class {{Name}} : BaseEntity
 {
-    {{ for prop in Properties }}
-    public {{ prop.Type }} {{ prop.Name }} { get; set; }
-    {{ end }}
+{{~ for prop in Properties ~}}
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; set; }
+{{~ end ~}}
 }
diff --git a/Templates/Features/Mvc/Models/{{Name}}.cs b/Templates/Features/Mvc/Models/{{Name}}.cs
index 9844621..2d33b29 100644
--- a/Templates/Features/Mvc/Models/{{Name}}.cs
+++ b/Templates/Features/Mvc/Models/{{Name}}.cs
@@ -3,7 +3,7 @@ namespace {{ProjectName}}.Models;
 public class {{Name}}
 {
     public int Id { get; set; }
-    {{ for prop in Properties }}
-    public {{ prop.Type }} {{ prop.Name }} { get; set; }
-    {{ end }}
+{{~ for prop in Properties ~}}
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; set; }
+{{~ end ~}}
 }
diff --git a/Templates/Features/Mvc/Views/{{Name}}/Create.cshtml b/Templates/Features/Mvc/Views/{{Name}}/Create.cshtml
index c6392c0..08a2eec 100644
--- a/Templates/Features/Mvc/Views/{{Name}}/Create.cshtml
+++ b/Templates/Features/Mvc/Views/{{Name}}/Create.cshtml
@@ -10,13 +10,13 @@
     <div class="col-md-4">
         <form asp-action="Create">
             <div asp-validation-summary="ModelOnly" class="text-danger"></div>
-            {{ for prop in Properties }}
+{{~ for prop in Properties ~}}
             <div class="form-group">
                 <label asp-for="{{ prop.Name }}" class="control-label"></label>
                 <input asp-for="{{ prop.Name }}" class="form-control" />
                 <span asp-validation-for="{{ prop.Name }}" class="text-danger"></span>
             </div>
-            {{ end }}
+{{~ end ~}}
             <div class="form-group">
                 <input type="submit" value="Create" class="btn btn-primary" />
             </div>
diff --git a/Templates/Features/Mvc/Views/{{Name}}/Index.cshtml b/Templates/Features/Mvc/Views/{{Name}}/Index.cshtml
index afb0aa9..9f9a0fa 100644
--- a/Templates/Features/Mvc/Views/{{Name}}/Index.cshtml
+++ b/Templates/Features/Mvc/Views/{{Name}}/Index.cshtml
@@ -12,18 +12,18 @@
 <table class="table">
     <thead>
         <tr>
-            {{ for prop in Properties }}
+{{~ for prop in Properties ~}}
             <th>{{ prop.Name }}</th>
-            {{ end }}
+{{~ end ~}}
             <th></th>
         </tr>
     </thead>
     <tbody>
 @foreach (var item in Model) {
         <tr>
-            {{ for prop in Properties }}
+{{~ for prop in Properties ~}}
             <td>@Html.DisplayFor(modelItem => item.{{ prop.Name }})</td>
-            {{ end }}
+{{~ end ~}}
         </tr>
 }
     </tbody>
diff --git a/Templates/Features/VerticalSlice/{{Name}}/Create{{Name}}.cs b/Templates/Features/VerticalSlice/{{Name}}/Create{{Name}}.cs
index dbdd0e6..bf03364 100644
--- a/Templates/Features/VerticalSlice/{{Name}}/Create{{Name}}.cs
+++ b/Templates/Features/VerticalSlice/{{Name}}/Create{{Name}}.cs
@@ -4,9 +4,9 @@
 namespace {{ProjectName}}.Features.{{Name}}s;
 
 public record Create{{Name}}Command(
-    {{ for prop in Properties }}
+{{~ for prop in Properties ~}}
     {{ prop.Type }} {{ prop.Name }}{{ if !for.last }},{{ end }}
-    {{ end }}
+{{~ end ~}}
 ) : IRequest<int>;
 
 public class Create{{Name}}Handler : IRequestHandler<Create{{Name}}Command, int>
@@ -22,9 +22,9 @@ public async Task<int> Handle(Create{{Name}}Command request, CancellationToken c
     {
         var entity = new {{Name}}
         {
-            {{ for prop in Properties }}
+{{~ for prop in Properties ~}}
             {{ prop.Name }} = request.{{ prop.Name }},
-            {{ end }}
+{{~ end ~}}
         };
 
         _db.Set<{{Name}}>().Add(entity);
diff --git a/Templates/Features/VerticalSlice/{{Name}}/{{Name}}.cs b/Templates/Features/VerticalSlice/{{Name}}/{{Name}}.cs
index 4e9ec37..cb304ac 100644
--- a/Templates/Features/VerticalSlice/{{Name}}/{{Name}}.cs
+++ b/Templates/Features/VerticalSlice/{{Name}}/{{Name}}.cs
@@ -3,7 +3,7 @@ namespace {{ProjectName}}.Features.{{Name}}s;
 public class {{Name}}
 {
     public int Id { get; set; }
-    {{ for prop in Properties }}
-    public {{ prop.Type }} {{ prop.Name }} { get; set; }
-    {{ end }}
+{{~ for prop in Properties ~}}
+    public {{ if !prop.IsValueType }}required {{ end }}{{ prop.Type }} {{ prop.Name }} { get; set; }
+{{~ end ~}}
 }
diff --git a/Templates/MvcMonolith/{{Name}}/{{Name}}.csproj b/Templates/MvcMonolith/{{Name}}/{{Name}}.csproj
index 6568b3d..a3a34b6 100644
--- a/Templates/MvcMonolith/{{Name}}/{{Name}}.csproj
+++ b/Templates/MvcMonolith/{{Name}}/{{Name}}.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
diff --git a/Templates/VerticalSlice/{{Name}}/{{Name}}.csproj b/Templates/VerticalSlice/{{Name}}/{{Name}}.csproj
index 2dafa7f..f8294d3 100644
--- a/Templates/VerticalSlice/{{Name}}/{{Name}}.csproj
+++ b/Templates/VerticalSlice/{{Name}}/{{Name}}.csproj
@@ -1,15 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.0" />
-    <PackageReference Include="MediatR" Version="12.2.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.10" />
+    <!-- Pinned above the version AspNetCore.OpenApi pulls in transitively, which
+         carries a known advisory (GHSA-v5pm-xwqc-g5wc). -->
+    <PackageReference Include="Microsoft.OpenApi" Version="2.11.0" />
+    <PackageReference Include="MediatR" Version="12.4.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.10" />
   </ItemGroup>
 
 </Project>
diff --git a/publish.sh b/publish.sh
index faca520..eeca767 100755
--- a/publish.sh
+++ b/publish.sh
@@ -6,7 +6,7 @@ set -e
 echo "🚀 Starting MTC Build Process..."
 
 # Define version
-VERSION="1.0.2"
+VERSION="1.1.0"
 OUTPUT_DIR="./dist"
 
 # Clean previous builds