refactor(arch)!: Kernel ring + structural realignment close-out (onion 5a–5c + project renames/splits + Fallout meta)

.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,21 +1,24 @@
 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.Application.Tools")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.CI")]
 [assembly: InternalsVisibleTo("Fallout.Common.Tests")]
 [assembly: InternalsVisibleTo("Fallout.Cli")]
 [assembly: InternalsVisibleTo("Fallout.Cli.Tests")]
 [assembly: InternalsVisibleTo("Fallout.ProjectModel.Tests")]
 [assembly: InternalsVisibleTo("Fallout.SourceGenerators")]
-[assembly: InternalsVisibleTo("Fallout.Solution")]
+[assembly: InternalsVisibleTo("Fallout.Application.Solutions")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Solutions")]
 [assembly: InternalsVisibleTo("Fallout.Solution.Tests")]
 [assembly: InternalsVisibleTo("Fallout.Persistence.Solution")]
 [assembly: InternalsVisibleTo("Fallout.Persistence.Solution.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Tooling")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tooling")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Tooling")]
 [assembly: InternalsVisibleTo("Fallout.Tooling.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Utilities.IO.Globbing")]
+[assembly: InternalsVisibleTo("Fallout.Kernel.IO.Globbing")]
 [assembly: InternalsVisibleTo("Fallout.Utilities.Tests")]
 
 // External extensions — kept as Nuke.* until those projects rebrand independently.

CHANGELOG.md

@@ -15,6 +15,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
   - **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.
 - **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.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,12 +1,12 @@
 using System;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities.Collections;
 using static Fallout.CodeGeneration.CodeGenerator;
 using static Fallout.CodeGeneration.ReferenceUpdater;
 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,12 +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.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,16 +2,16 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using Fallout.Common.IO;
-using Fallout.Solutions;
-using Fallout.Common.Utilities;
-using Fallout.Utilities.Text.Yaml;
+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
 {
@@ -21,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 System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using Fallout.Common.IO;
 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,11 +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,9 +1,8 @@
 using System;
-using Fallout.Common;
-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.Threading.Tasks;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities;
 using Fallout.Application;
 using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
 
 partial class Build
 {

build/Build.cs

@@ -2,11 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using NuGet.Packaging;
-using Fallout.Common;
-using Fallout.Common.CI.GitHubActions;
-using Fallout.Common.IO;
-using Fallout.Solutions;
-using Fallout.Common.Utilities;
 using static Fallout.Application.ControlFlow;
 using static Fallout.Application.Tools.DotNet.DotNetTasks;
 using Fallout.Application;
@@ -18,6 +13,11 @@
 using Fallout.Application.Tooling;
 using Fallout.Infrastructure.Tooling;
 using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
+using Fallout.Infrastructure.CI.GitHubActions;
+using Fallout.Application.Solutions;
+using Fallout.Infrastructure.ProjectModel;
 
 [DotNetVerbosityMapping]
 [ShutdownDotNetAfterServerBuild]
@@ -41,7 +41,7 @@ partial class Build
     GitRepository GitRepository => From<IHasGitRepository>().GitRepository;
 
     [Solution(GenerateProjects = true)] readonly Solution Solution;
-    Fallout.Solutions.Solution IHasSolution.Solution => Solution;
+    Fallout.Application.Solutions.Solution IHasSolution.Solution => Solution;
 
     AbsolutePath OutputDirectory => RootDirectory / "output";
     AbsolutePath SourceDirectory => RootDirectory / "source";
@@ -98,12 +98,12 @@ private static int ParseMajor(string informationalVersion)
         .When(!ScheduledTargets.Contains(((IPublish)this).Publish) && !ScheduledTargets.Contains(Install), _ => _
             .ClearProperties());
 
-    IEnumerable<(Fallout.Solutions.Project Project, string Framework)> ICompile.PublishConfigurations =>
+    IEnumerable<(Fallout.Application.Solutions.Project Project, string Framework)> ICompile.PublishConfigurations =>
         from project in new[] { Solution.Fallout_Cli, Solution.Fallout_MSBuildTasks }
         from framework in project.GetTargetFrameworks()
         select (project, framework);
 
-    IEnumerable<Fallout.Solutions.Project> ITest.TestProjects => Partition.GetCurrent(Solution.GetAllProjects("*.Tests"));
+    IEnumerable<Fallout.Application.Solutions.Project> ITest.TestProjects => Partition.GetCurrent(Solution.GetAllProjects("*.Tests"));
 
     [Parameter]
     public int TestDegreeOfParallelism { get; } = 1;

build/_build.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="..\src\Fallout.Common\Fallout.Common.props" />
+  <Import Project="..\src\Fallout\Fallout.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -66,11 +66,26 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\src\Fallout.Components\Fallout.Components.csproj" />
+    <ProjectReference Include="..\src\Fallout.Application.Components\Fallout.Application.Components.csproj" />
+    <!-- The MSBuild project-query extensions (GetTargetFrameworks etc.) are Infrastructure; a build
+         (consumer) references them directly now that they no longer flow transitively via the rings. -->
+    <ProjectReference Include="..\src\Fallout.Infrastructure.ProjectModel\Fallout.Infrastructure.ProjectModel.csproj" />
     <ProjectReference Include="..\src\Fallout.Tooling.Generator\Fallout.Tooling.Generator.csproj" />
     <ProjectReference Include="..\src\Fallout.SourceGenerators\Fallout.SourceGenerators.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
   </ItemGroup>
 
-  <Import Project="..\src\Fallout.Common\Fallout.Common.targets" />
+  <Import Project="..\src\Fallout\Fallout.targets" />
+
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\Fallout.Infrastructure.Solutions\Fallout.Infrastructure.Solutions.csproj" />
+  </ItemGroup>
+
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\Fallout.Application.Tools\Fallout.Application.Tools.csproj" />
+    <ProjectReference Include="..\src\Fallout.Infrastructure.CI\Fallout.Infrastructure.CI.csproj" />
+    <ProjectReference Include="..\src\Fallout.Infrastructure.Tooling\Fallout.Infrastructure.Tooling.csproj" />
+  </ItemGroup>
 
 </Project>