refactor(arch)!: onion layering + namespace realignment (ADR-0006)

.fallout/build.schema.json

@@ -148,6 +148,16 @@
           "type": "string",
           "default": "Secrets must be entered via 'nuke :secrets [profile]'"
         },
+        "NuGetSource": {
+          "type": "string"
+        },
+        "PublishTo": {
+          "type": "array",
+          "description": "Publish only to these named targets (default: all configured PublishTargets)",
+          "items": {
+            "type": "string"
+          }
+        },
         "Solution": {
           "type": "string",
           "description": "Path to a solution file that is automatically loaded"

AssemblyInfo.cs

@@ -1,22 +1,27 @@
 using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("Fallout.Build")]
+[assembly: InternalsVisibleTo("Fallout.Application")]
 [assembly: InternalsVisibleTo("Fallout.Build.Shared")]
-[assembly: InternalsVisibleTo("Fallout.Build.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Common")]
-[assembly: InternalsVisibleTo("Fallout.Common.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tools")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.CI")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tools.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.CI.Tests")]
 [assembly: InternalsVisibleTo("Fallout.Cli")]
 [assembly: InternalsVisibleTo("Fallout.Cli.Tests")]
-[assembly: InternalsVisibleTo("Fallout.ProjectModel.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.ProjectModel.Tests")]
 [assembly: InternalsVisibleTo("Fallout.SourceGenerators")]
-[assembly: InternalsVisibleTo("Fallout.Solution")]
-[assembly: InternalsVisibleTo("Fallout.Solution.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Solutions")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Solutions")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Solutions.Tests")]
 [assembly: InternalsVisibleTo("Fallout.Persistence.Solution")]
 [assembly: InternalsVisibleTo("Fallout.Persistence.Solution.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Tooling")]
-[assembly: InternalsVisibleTo("Fallout.Tooling.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Utilities.IO.Globbing")]
-[assembly: InternalsVisibleTo("Fallout.Utilities.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tooling")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Tooling")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tooling.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Tooling.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Kernel.IO.Globbing")]
+[assembly: InternalsVisibleTo("Fallout.Kernel.Tests")]
 
 // External extensions — kept as Nuke.* until those projects rebrand independently.
 [assembly: InternalsVisibleTo("Nuke.VisualStudio")]

CHANGELOG.md

@@ -8,6 +8,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Breaking changes
 
+- **Onion layering — namespace realignment begun; `Fallout.Core` → `Fallout.Domain`** ([ADR-0006](docs/adr/0006-onion-layering-and-namespace-realignment.md)). First ring of a project-wide realignment to explicit onion layers (`Fallout.Domain` / `Fallout.Application` / `Fallout.Infrastructure`, `Fallout.Cli` composition root) with `namespace = project = layer`, dissolving the `Fallout.Common.*` catch-all. This entry covers **step 1 (the Domain ring)**; the Application/Infrastructure/tooling-port rings land on `experimental` as separate PRs (any that miss the 2026 cut roll to 2027).
+  - **Namespaces**: `Fallout.Core.Planning` → `Fallout.Domain.Planning`; `ITargetModel` and `ExecutionStatus` move out of `Fallout.Common.Execution` → `Fallout.Domain.Execution`. **Package/assembly**: `Fallout.Core` → `Fallout.Domain`. Replace the corresponding `using` directives and any `PackageReference`/`ProjectReference`.
+  - **Migration / shim**: the `Nuke.*` transition shims silently stop re-exporting the two moved types (the generator only mirrors the `Fallout.Common.*` prefix). A fresh migration/shim strategy is designed once the realignment completes (ADR-0006 defers it deliberately); native `Fallout.*` consumers rewrite the two `using`s above.
+  - **Step 2 (the Application ring)**: the core API `Fallout.Build` declared under `Fallout.Common.*` — `FalloutBuild`, `Target`, `[Parameter]` & attributes, `Host`, the execution engine, value injection, and the CI ports — moves to **`Fallout.Application.*`**. Native consumers rewrite `using Fallout.Common;` → `using Fallout.Application;` (and the `Fallout.Common.Execution`/`.CI`/`.ValueInjection` sub-namespaces likewise). Performed by a semantic rewriter (`tools/OnionRewriter`). The `Nuke.*` shim surface that mirrored these (`Nuke.Common.Target`, `…Parameter`, …) lapses for now — `Nuke.Consumer` and `Nuke.Common.Shim.Tests` are temporarily out of the solution until the migration phase. The `Fallout.Build` **assembly/project** is renamed to `Fallout.Application` in a later mechanical step (namespaces are already migrated).
+  - **Step 4a (Application ring — composition components)**: the build-composition interface family (`ICompile`, `IRestore`, `IPack`, `IPublish`, `ITest`, `IHas*`, `Configuration`, …), previously `Fallout.Components`, moves to **`Fallout.Application.Components`** — it composes the tool/CI vocabulary and so belongs in the Application ring. Native consumers rewrite `using Fallout.Components;` → `using Fallout.Application.Components;`. The `Nuke.Components` transition shim is unaffected for consumers: its public `Nuke.Components.*` face is unchanged (the shim generator's source prefix was repointed to the new namespace). The `Fallout.Components` **assembly/project** keeps its filename until the later mechanical rename step.
+  - **Step 4b (tool vocabulary → Application; executor → Infrastructure)**: the tool wrappers `Fallout.Common.Tools.*` (60+ wrappers) and the tool vocabulary they build on (`ToolTasks`, `ToolOptions`, `Output`, `Configure<T>`, the `IProcess`/`IProcessRunner` ports, requirement/attribute types) move to **`Fallout.Application.Tools.*`** / **`Fallout.Application.Tooling`**. The impure executor that shared the `Fallout.Common.Tooling` namespace — `ProcessTasks`, `SystemProcessRunner`, `Process2`, `ProcessExtensions`, `ToolExecutor`, and the tool/package/version resolvers — moves to **`Fallout.Infrastructure.Tooling`**. Native consumers rewrite `using Fallout.Common.Tools.*;` → `using Fallout.Application.Tools.*;` and `using Fallout.Common.Tooling;` → `using Fallout.Application.Tooling;` (plus `using Fallout.Infrastructure.Tooling;` where they touch the executor directly). The `Nuke.Common.Tools`/`…Tooling` shim aliases lapse (the generator only mirrors the `Fallout.Common.*` prefix), pending the deferred migration/shim redesign. Assembly/project files (`Fallout.Common`, `Fallout.Tooling`) are unchanged; only namespaces moved.
+  - **Step 4b-follow-up (port inversion + Application-ring fitness gate)**: the impure tool-execution services now sit behind ports in `Fallout.Application.Tooling` — **`IProcessExecutor`**, **`IToolPathResolver`**, **`IToolVersionResolver`**, resolved via the new **`ToolingServices`** locator; Infrastructure registers thin adapters into it through a module initializer. The Application ring (tool wrappers, `ToolTasks`, `ToolResolver`, requirement/version attributes, build orchestration) no longer references `Fallout.Infrastructure.*`. `ProcessExtensions` (pure `IProcess`/`Output` helpers — `AssertWaitForExit`, `StdToJson`, …) was reclassified from Infrastructure back to `Fallout.Application.Tooling`. A NetArchTest fitness test (new `Fallout.Architecture.Tests`) asserts `Fallout.Application.*` ⊥ `Fallout.Infrastructure.*` and guards it. (Catch-all `Fallout.Common.*` code outside the Application ring — e.g. CI host adapters, single-file/path-check attributes — still reaches Infrastructure and is addressed when those namespaces get a ring in step 5.)
+  - **Step 5a (the `Fallout.Kernel` ring)**: the shared utility/IO layer — pure helpers (collections, string/text, reflection, `Assert`-adjacent guards, crypto, JSON/YAML), the `AbsolutePath`/`RelativePath` value types **and their fluent filesystem operations** (`.ReadAllText`/`.GlobFiles`/`.CreateDirectory`/…), plus HTTP/compression helpers — moves from `Fallout.Common.Utilities*` / `Fallout.Common.IO` to **`Fallout.Kernel`** / **`Fallout.Kernel.IO`** / **`Fallout.Kernel.Collections`** / **`Fallout.Kernel.Net`**, the innermost shared ring that the Domain/Application/Infrastructure rings build on. Native consumers rewrite `using Fallout.Common.Utilities;` → `using Fallout.Kernel;` (and `.Collections`/`.Net`) and `using Fallout.Common.IO;` → `using Fallout.Kernel.IO;`. **Filesystem is treated as a kernel-level capability** (like the BCL `File`/`Directory`): the fluent `AbsolutePath` API is used pervasively across the Application ring, so routing it through ports would be impractical and anti-ergonomic — it stays in Kernel rather than moving to Infrastructure. Pushing the genuinely-external adapters (HTTP/FTP, compression) further out to Infrastructure is deferred for the same reason (they need the same ports decision). The `Fallout.Utilities` assembly/project keeps its filename until the later mechanical rename to `Fallout.Kernel`; a few root-`Fallout.Common` guards (`Assert`, `NotNull`, `EnvironmentInfo`) remain in the dissolving catch-all for now and fold into Kernel later.
+  - **Step 5b (CI host providers → Infrastructure)**: the concrete CI provider classes (`AppVeyor`, `AzurePipelines`, `TeamCity`, `GitHubActions`, `GitLab`, `TravisCI`, …) and their config generators move from `Fallout.Common.CI.*` to **`Fallout.Infrastructure.CI.*`**. The Application ring reaches the provider-specific capabilities it needs (publish test results/coverage, push artifacts, set/update the build number, read the token, …) through new **ports in `Fallout.Application.CI`** — `IAppVeyor`/`IAzurePipelines`/`ITeamCity`/`IGitHubActions` plus a **`CiHost`** accessor that casts the detected `Host.Instance` to the port (no registration needed — `Host.Instance` is the existing detection seam). Components and version/coverage attributes rewrite `AzurePipelines.Instance?.X` → `CiHost.AzurePipelines?.X`, so the Application ring stays free of `Fallout.Infrastructure.*` (the fitness gate still passes). The two enums the ports expose (`AzurePipelinesTestResultsType`, `AzurePipelinesCodeCoverageToolType`) move to `Fallout.Application.CI` as vocabulary. The `Nuke.Common.CI.*` transition-shim host accessors are repointed to the new Infrastructure namespace. (The generic CI host abstraction — ADR-0005 `IBuildHost`/`IBuildReporter`, [#341] — remains a separate, additive effort.)
+  - **Step 5c (ProjectModel/Solution → rings)**: the solution model + `[Solution]` injection + `ReadSolution` move to **`Fallout.Application.Solutions`** (a Fallout-owned POCO model with an opaque handle, behind `ISolutionSerializer`/`IProjectEditor` ports + a `SolutionServices` locator); the `.sln`/`.slnx` serializer adapter → **`Fallout.Infrastructure.Solutions`**; the MSBuild project evaluator (`ProjectModelTasks`/`ProjectExtensions`) → **`Fallout.Infrastructure.ProjectModel`**. Also finished the partial straggler moves (Git/ChangeLog → `Fallout.Application.*`; `Assert`/`EnvironmentInfo`/`AsyncHelper`/`ArgumentParser` → `Fallout.Kernel`; Execution + Gitter → Application).
+  - **Project-file renames + splits + meta-package (the mechanical step the entries above forward-referenced)**: with namespaces settled, the **project files, assemblies, and NuGet package IDs** now match the rings. Pure renames: `Fallout.Build` → **`Fallout.Application`**, `Fallout.Components` → **`Fallout.Application.Components`**, `Fallout.ProjectModel` → **`Fallout.Infrastructure.ProjectModel`**, `Fallout.Utilities*` → **`Fallout.Kernel*`**. Mixed projects split into ring-pure assemblies: `Fallout.Tooling` → **`Fallout.Application.Tooling`** + **`Fallout.Infrastructure.Tooling`**; `Fallout.Solution` → **`Fallout.Application.Solutions`** + **`Fallout.Infrastructure.Solutions`**; the 249-file **`Fallout.Common` catch-all is dissolved** → `Fallout.Application.Tools` (tool wrappers), `Fallout.Infrastructure.CI` (CI adapters), `Fallout.Application`, and `Fallout.Kernel`. **Consumers now reference a new thin `Fallout` meta-package** (successor to `Fallout.Common` — references every ring + carries the MSBuild integration `Fallout.props`/`.targets`, the MSBuildTasks output, and the source-generator analyzer); `dotnet fallout :setup`/`:update` target `Fallout`. **Package-ID migration**: replace `Fallout.Common` → `Fallout`; `Fallout.Build`/`.Components`/`.ProjectModel`/`.Tooling`/`.Solution`/`.Utilities*` → their ring names above. **TFMs**: dropped `net472` from `Fallout.MSBuildTasks` (Fallout is `dotnet build`-only); `Fallout.Domain` → `net10.0`; netstandard2.0 retained only on the Roslyn generators and the ring halves they consume (`Fallout.Application.Tooling`/`.Solutions`, `Fallout.Kernel*`, `Fallout.Build.Shared`); `Fallout.Infrastructure.ProjectModel` keeps `net8.0;net9.0;net10.0` (per-TFM Microsoft.Build SDK matching). The fitness gate now operates on ring-pure assemblies. The build's own `[ModuleInitializer]` force-loader now runs each `Fallout.*` assembly's module constructor (`RuntimeHelpers.RunModuleConstructor`), so the split-out Infrastructure adapters register deterministically.
+  - **Shim + migration redesign (the deferred `Nuke.*` strategy, now landed)**: a single canonical `Nuke ↔ Fallout` namespace map (`src/Shared/NukeNamespaceMap.cs`) drives both the transition shims (Fallout→Nuke re-exports) and the `fallout-migrate` rewriters (Nuke→Fallout), which the realignment had desynchronised (the migration was emitting dead `Fallout.Common.*` namespaces). **Shim packages collapse from 3 to 2**: `Nuke.Common` (now references the `Fallout` meta-package and re-exports every `Nuke.Common.*` sub-namespace — Tooling/Tools/CI/ProjectModel/Git/IO/Execution/ValueInjection/ChangeLog/Utilities — wherever the source type now lives across the rings) and `Nuke.Components`. **`Nuke.Build` is removed** (it was never a real NUKE consumer package — `NukeBuild` lives in `Nuke.Common`); consumers who referenced it migrate to `Fallout`. **The migration's package rewrite** maps the `Nuke.Common` package → the `Fallout` meta and `Nuke.Components` → `Fallout.Application.Components` (not a dead `Fallout.Common`/`Fallout.Components`). **`dotnet fallout` Cake migration support (`:cakeconvert`/`:cakeclean`) is dropped** entirely.
 - **Adopted calendar versioning (`YYYY.MINOR.PATCH`) + dual-pace channel model; retired the v11 numbering** ([ADR-0004](docs/adr/0004-calendar-versioning-and-dual-pace-channels.md)). Fallout now ships on calendar versions (`2026.0.0`, `2026.1.0`, …) — mechanically valid SemVer with the major equal to the calendar year. **Breaking changes are batched to the yearly major cut**; mid-year stable releases (`release/YYYY`) are strictly non-breaking. `main` becomes the published **edge** channel (date-stamped prereleases to GitHub Packages); the slow/stable track lives on `release/YYYY`. Opt-in unstable APIs are marked `[Experimental("FALLOUT0xx")]`.
   - **Migration / impact**: the `11.0.x` packages never shipped a clean stable release (all unlisted), so this strands no stable consumers. The headline content previously slated for "v11" now ships as **`2026.0.0`**. Any tooling pinned to a `[11.0,12.0)`-style range should retarget the `2026.x` line.
   - **Legacy unaffected**: the `release/v10` line stays on semver `10.x` and continues to receive security/critical fixes — v10 consumers do nothing.

build/Build.CI.GitHubActions.cs

@@ -1,5 +1,5 @@
-using Fallout.Common.CI.GitHubActions;
-using Fallout.Components;
+using Fallout.Application.Components;
+using Fallout.Infrastructure.CI.GitHubActions;
 
 // Cross-platform (macOS/Windows) full Test+Pack is gated to RELEASE INTENT
 // (#318/#326): it runs only on a PR into a production branch (release/YYYY,

build/Build.CodeGeneration.cs

@@ -1,11 +1,12 @@
-using System;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities.Collections;
+using System;
 using static Fallout.CodeGeneration.CodeGenerator;
 using static Fallout.CodeGeneration.ReferenceUpdater;
-using static Fallout.Common.Tools.Git.GitTasks;
+using static Fallout.Application.Tools.Git.GitTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.Git;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
 
 partial class Build
 {

build/Build.Contributors.cs

@@ -1,10 +1,11 @@
 using System.Linq;
 using System.Text;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.Git.GitTasks;
+using static Fallout.Application.Tools.Git.GitTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.Git;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
+using Fallout.Kernel;
 
 partial class Build
 {

build/Build.GlobalSolution.cs

@@ -2,15 +2,16 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Git;
-using Fallout.Common.IO;
-using Fallout.Solutions;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities;
-using Fallout.Utilities.Text.Yaml;
-using static Fallout.Common.ControlFlow;
-using static Fallout.Common.Tools.Git.GitTasks;
+using Fallout.Kernel;
+using static Fallout.Application.ControlFlow;
+using static Fallout.Application.Tools.Git.GitTasks;
+using Fallout.Application;
+using Fallout.Application.Git;
+using Fallout.Application.Tools.Git;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Text.Yaml;
+using Fallout.Application.Solutions;
 
 partial class Build
 {
@@ -20,7 +21,7 @@ partial class Build
     AbsolutePath ExternalRepositoriesDirectory => RootDirectory / "external";
     AbsolutePath ExternalRepositoriesFile => ExternalRepositoriesDirectory / "repositories.yml";
 
-    IEnumerable<Fallout.Solutions.Solution> ExternalSolutions
+    IEnumerable<Fallout.Application.Solutions.Solution> ExternalSolutions
         => ExternalRepositories
             .Select(x => ExternalRepositoriesDirectory / x.GetGitHubName())
             .Select(x => x.GlobFiles("*.sln").Single())

build/Build.Licenses.cs

@@ -1,11 +1,12 @@
-using Fallout.Common;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using Fallout.Common.IO;
-using Fallout.Components;
 using Serilog;
-using static Fallout.Common.IO.HttpTasks;
+using static Fallout.Application.IO.HttpTasks;
+using Fallout.Application;
+using Fallout.Application.Components;
+using Fallout.Kernel.IO;
+using Fallout.Application.IO;
 
 partial class Build
 {

build/Build.PublicApi.cs

@@ -2,10 +2,10 @@
 using System.Linq;
 using System.Reflection;
 using System.Text;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
+using Fallout.Application;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
+using Fallout.Kernel;
 
 partial class Build
 {

build/Build.RunTargetInDockerTest.cs

@@ -1,8 +1,8 @@
 using System;
-using Fallout.Common;
-using Fallout.Common.Tools.Docker;
-using Fallout.Common.Utilities;
 using Serilog;
+using Fallout.Application;
+using Fallout.Application.Tools.Docker;
+using Fallout.Kernel;
 
 partial class Build
 {

build/Build.Stargazers.cs

@@ -1,9 +1,9 @@
-using System.Linq;
+using System.Linq;
 using System.Threading.Tasks;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities;
+using Fallout.Application;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
 
 partial class Build
 {

build/Build.Terminal.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
 using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Execution;
+using Fallout.Application.Execution;
+using Fallout.Application;
 
 [DisableDefaultOutput<Terminal>(
     DefaultOutput.Logo,