From 01287d2868e5905f9de80c63aa710a0b42ca78a9 Mon Sep 17 00:00:00 2001 From: GAJ3T Date: Wed, 28 Oct 2026 11:08:30 -0400 Subject: [PATCH] After Step 1 --- .editorconfig | 21 + .gitignore | 7 + Directory.Build.props | 8 + Directory.Packages.props | 15 + NuGet.Config | 7 + README.md | 154 +++++- docs/README.md | 21 + docs/adr-0001-headless-foundation.md | 55 ++ docs/adr-0002-single-shell-vsa.md | 68 +++ docs/architecture.md | 108 ++++ docs/build-and-test.md | 94 ++++ global.json | 7 + prompts/ROADMAP.md | 226 ++++++-- prompts/STATE.md | 205 ++++++-- prompts/Step-01-Report.md | 402 ++++++++++++++ prompts/Step-01A-Report.md | 204 ++++++++ prompts/Step-01A.md | 399 ++++++++++++++ prompts/Step-02.md | 493 ++++++++++++++++++ .../AutoForge.Application.csproj | 15 + .../ExecutionTargetResolver.cs | 53 ++ .../IExecutionTargetResolver.cs | 9 + .../ServiceCollectionExtensions.cs | 25 + .../TargetSelectionException.cs | 13 + .../TargetSelectionFailure.cs | 9 + src/AutoForge.Client/.gitignore | 11 + src/AutoForge.Client/App.xaml | 17 + src/AutoForge.Client/App.xaml.cs | 14 + src/AutoForge.Client/AutoForge.Client.csproj | 67 +++ src/AutoForge.Client/MainPage.xaml | 13 + src/AutoForge.Client/MainPage.xaml.cs | 9 + src/AutoForge.Client/MauiProgram.cs | 27 + .../Platforms/Windows/App.xaml | 8 + .../Platforms/Windows/App.xaml.cs | 24 + .../Platforms/Windows/Package.appxmanifest | 46 ++ .../Platforms/Windows/app.manifest | 17 + .../Properties/launchSettings.json | 8 + .../Resources/AppIcon/appicon.svg | 4 + .../Resources/AppIcon/appiconfg.svg | 8 + .../Resources/Fonts/OpenSans-Regular.ttf | Bin 0 -> 107048 bytes .../Resources/Raw/AboutAssets.txt | 15 + .../Resources/Splash/splash.svg | 8 + src/AutoForge.Client/wwwroot/index.html | 27 + .../AutoForge.Components.csproj | 14 + src/AutoForge.Components/StatusNotice.razor | 15 + .../StatusNotice.razor.css | 25 + src/AutoForge.Components/StatusNoticeTone.cs | 9 + src/AutoForge.Components/_Imports.razor | 2 + src/AutoForge.Core/AutoForge.Core.csproj | 7 + .../ExecutionTargetDescriptor.cs | 28 + .../ExecutionTargets/ExecutionTargetKind.cs | 8 + src/AutoForge.UI/AutoForge.UI.csproj | 19 + .../ExecutionTargetSelectionPage.razor | 41 ++ .../ExecutionTargetSelectionPage.razor.css | 30 ++ .../ExecutionTargetSelectionViewModel.cs | 62 +++ .../Features/Foundation/AddAutoForgeUi.cs | 15 + .../Features/Foundation/Home.razor | 14 + .../Features/Foundation/NotFoundPage.razor | 5 + src/AutoForge.UI/Layout/MainLayout.razor | 19 + src/AutoForge.UI/Layout/MainLayout.razor.css | 51 ++ src/AutoForge.UI/Routes.razor | 10 + src/AutoForge.UI/_Imports.razor | 7 + src/AutoForge.UI/wwwroot/app.css | 45 ++ src/AutoForge.slnx | 11 + .../AutoForge.IntegrationTests.csproj | 30 ++ .../ProjectGraphTests.cs | 115 ++++ .../TargetSelectionCompositionTests.cs | 191 +++++++ .../UiCompositionTests.cs | 189 +++++++ .../AutoForge.UnitTests.csproj | 29 ++ .../ExecutionTargetDescriptorTests.cs | 55 ++ .../ExecutionTargetResolverTests.cs | 168 ++++++ .../StatusNoticeRenderingTests.cs | 45 ++ 71 files changed, 4102 insertions(+), 98 deletions(-) create mode 100644 .editorconfig create mode 100644 Directory.Build.props create mode 100644 Directory.Packages.props create mode 100644 NuGet.Config create mode 100644 docs/README.md create mode 100644 docs/adr-0001-headless-foundation.md create mode 100644 docs/adr-0002-single-shell-vsa.md create mode 100644 docs/architecture.md create mode 100644 docs/build-and-test.md create mode 100644 global.json create mode 100644 prompts/Step-01-Report.md create mode 100644 prompts/Step-01A-Report.md create mode 100644 prompts/Step-01A.md create mode 100644 prompts/Step-02.md create mode 100644 src/AutoForge.Application/AutoForge.Application.csproj create mode 100644 src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetResolver.cs create mode 100644 src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/IExecutionTargetResolver.cs create mode 100644 src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ServiceCollectionExtensions.cs create mode 100644 src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionException.cs create mode 100644 src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionFailure.cs create mode 100644 src/AutoForge.Client/.gitignore create mode 100644 src/AutoForge.Client/App.xaml create mode 100644 src/AutoForge.Client/App.xaml.cs create mode 100644 src/AutoForge.Client/AutoForge.Client.csproj create mode 100644 src/AutoForge.Client/MainPage.xaml create mode 100644 src/AutoForge.Client/MainPage.xaml.cs create mode 100644 src/AutoForge.Client/MauiProgram.cs create mode 100644 src/AutoForge.Client/Platforms/Windows/App.xaml create mode 100644 src/AutoForge.Client/Platforms/Windows/App.xaml.cs create mode 100644 src/AutoForge.Client/Platforms/Windows/Package.appxmanifest create mode 100644 src/AutoForge.Client/Platforms/Windows/app.manifest create mode 100644 src/AutoForge.Client/Properties/launchSettings.json create mode 100644 src/AutoForge.Client/Resources/AppIcon/appicon.svg create mode 100644 src/AutoForge.Client/Resources/AppIcon/appiconfg.svg create mode 100644 src/AutoForge.Client/Resources/Fonts/OpenSans-Regular.ttf create mode 100644 src/AutoForge.Client/Resources/Raw/AboutAssets.txt create mode 100644 src/AutoForge.Client/Resources/Splash/splash.svg create mode 100644 src/AutoForge.Client/wwwroot/index.html create mode 100644 src/AutoForge.Components/AutoForge.Components.csproj create mode 100644 src/AutoForge.Components/StatusNotice.razor create mode 100644 src/AutoForge.Components/StatusNotice.razor.css create mode 100644 src/AutoForge.Components/StatusNoticeTone.cs create mode 100644 src/AutoForge.Components/_Imports.razor create mode 100644 src/AutoForge.Core/AutoForge.Core.csproj create mode 100644 src/AutoForge.Core/ExecutionTargets/ExecutionTargetDescriptor.cs create mode 100644 src/AutoForge.Core/ExecutionTargets/ExecutionTargetKind.cs create mode 100644 src/AutoForge.UI/AutoForge.UI.csproj create mode 100644 src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor create mode 100644 src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor.css create mode 100644 src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionViewModel.cs create mode 100644 src/AutoForge.UI/Features/Foundation/AddAutoForgeUi.cs create mode 100644 src/AutoForge.UI/Features/Foundation/Home.razor create mode 100644 src/AutoForge.UI/Features/Foundation/NotFoundPage.razor create mode 100644 src/AutoForge.UI/Layout/MainLayout.razor create mode 100644 src/AutoForge.UI/Layout/MainLayout.razor.css create mode 100644 src/AutoForge.UI/Routes.razor create mode 100644 src/AutoForge.UI/_Imports.razor create mode 100644 src/AutoForge.UI/wwwroot/app.css create mode 100644 src/AutoForge.slnx create mode 100644 src/tests/AutoForge.IntegrationTests/AutoForge.IntegrationTests.csproj create mode 100644 src/tests/AutoForge.IntegrationTests/ProjectGraphTests.cs create mode 100644 src/tests/AutoForge.IntegrationTests/TargetSelectionCompositionTests.cs create mode 100644 src/tests/AutoForge.IntegrationTests/UiCompositionTests.cs create mode 100644 src/tests/AutoForge.UnitTests/AutoForge.UnitTests.csproj create mode 100644 src/tests/AutoForge.UnitTests/ExecutionTargetDescriptorTests.cs create mode 100644 src/tests/AutoForge.UnitTests/ExecutionTargetResolverTests.cs create mode 100644 src/tests/AutoForge.UnitTests/StatusNoticeRenderingTests.cs diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..9a600af --- /dev/null +++ b/.editorconfig @@ -0,0 +1,21 @@ +root = true + +[*] +charset = utf-8 +end_of_line = crlf +insert_final_newline = true +indent_style = space +indent_size = 4 +trim_trailing_whitespace = true + +[*.{json,xml,csproj,props,slnx}] +indent_size = 2 + +[*.md] +indent_size = 2 +end_of_line = lf +trim_trailing_whitespace = false + +[*.cs] +csharp_style_namespace_declarations = file_scoped:warning +dotnet_sort_system_directives_first = true diff --git a/.gitignore b/.gitignore index bc6c934..842a3f6 100644 --- a/.gitignore +++ b/.gitignore @@ -412,3 +412,10 @@ FodyWeavers.xsd # JetBrains Rider *.sln.iml +# Local environment secrets (keep shareable example files visible) +.env +.env.* +!.env.example + +# Private captures, firmware and model assets belong here, never in source fixtures +/src/local-data/ diff --git a/Directory.Build.props b/Directory.Build.props new file mode 100644 index 0000000..07a45fc --- /dev/null +++ b/Directory.Build.props @@ -0,0 +1,8 @@ + + + enable + enable + true + true + + diff --git a/Directory.Packages.props b/Directory.Packages.props new file mode 100644 index 0000000..93a5356 --- /dev/null +++ b/Directory.Packages.props @@ -0,0 +1,15 @@ + + + true + + + + + + + + + + + + diff --git a/NuGet.Config b/NuGet.Config new file mode 100644 index 0000000..765346e --- /dev/null +++ b/NuGet.Config @@ -0,0 +1,7 @@ + + + + + + + diff --git a/README.md b/README.md index 7c03f67..2c9e9c0 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,151 @@ -# AutoForge - -AI-assisted automotive diagnostics and programming platform. Read and back up vehicle data or build AI-researched vehicle profiles. Simulate control modules and driving scenarios, replay telemetry, and test calibration changes before real-world programming. Diagnose faults, read/clear trouble codes, and program supported vehicle modules. +# AutoForge + +## Product vision + +The following describes the product vision, not implemented capabilities: + +AI-assisted automotive diagnostics and programming platform. Read and back up +vehicle data or build AI-researched vehicle profiles. Simulate control modules +and driving scenarios, replay telemetry, and test calibration changes before +real-world programming. Diagnose faults, read/clear trouble codes, and program +supported vehicle modules. + +## Implementation status + +### IMPLEMENTED + +- Step-01 repository and headless Core/Application foundation, accepted + 2026-10-28; its original report remains historical evidence. +- Step-01A single Windows-first .NET MAUI Blazor Hybrid Client, UI and generic + Components RCLs, plus feature-oriented execution-target selection UI. +- Actual home, metadata-selection and not-found routes in the UI RCL; shared + accessible, text-safe status notices in Components. +- Immutable Simulation, RecordedReplay and PhysicalHardware target descriptors, + explicit provider/kind validation, case-insensitive exact metadata resolution, + no fallback, and DI composition in the in-process application. +- Selection and page messaging clearly state that metadata does not connect to a + vehicle or authorize any operation. + +Step-01A implementation, builds, tests and a native Windows smoke run are complete. +Manual orchestrator review and acceptance are pending; no later milestone has +started. Step-02 remains held and is not authorized by this report. + +### IN PROGRESS + +Manual Step-01A acceptance by the orchestrator. + +### PLANNED + +Vehicle/module profiles, deterministic AI-independent simulation, diagnostics, +telemetry and replay, calibration and backups, and replaceable local AI with +validated runbooks require later approved assignments. Hardware integration is a +future, initially read-only boundary with separate authorization/evidence gates +for any programming. No capability is implemented merely because it appears in +the product vision or roadmap. + +## Architecture + +One Windows-first **AutoForge.Client** .NET 10 MAUI Blazor Hybrid executable hosts +the entire application UI via `BlazorWebView`. **AutoForge.UI** owns routing, +navigation, layouts, pages and presentation. **AutoForge.Components** owns +vehicle-independent reusable UI. Application features run in-process in a +modular monolith; the Client is the composition root. There is no backend, +browser-hosted WASM shell, Blazor Server host or second application executable. + +The initial UI features are the foundation home page and explicit +execution-target metadata selection. Selection uses the existing real +Application resolver; the empty Client registration correctly shows +`ProviderNotRegistered`. No fake connected provider is installed to make the UI +look operational. + +```mermaid +flowchart TD + Client[MAUI Blazor Hybrid Client] --> UI[UI RCL: routes and feature screens] + UI --> Components[Reusable Components RCL] + UI --> App[Application feature slices] + Client --> App + App --> Core[Platform-neutral Core contracts] + UnitTests[Headless unit tests] --> Components + UnitTests --> Core + IntegrationTests[Headless rendered integration tests] --> UI + IntegrationTests --> App + IntegrationTests --> Core +``` + +`src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget` +owns the explicit selection feature while its public `AutoForge.Application.ExecutionTargets` +namespace remains stable. New application behaviors should form cohesive, +independently testable feature slices. Reusable engines and domain capabilities +stay independent of the UI; add no mediator, generic repository layer or empty +future-feature projects without a concrete need. + +## Repository layout + +```text +AutoForge/ + docs/ Technical docs and architecture decisions + prompts/ Manual assignments, state and worker evidence + src/ + AutoForge.slnx + AutoForge.Client/ The sole app executable; Windows MAUI Hybrid + AutoForge.UI/ Complete routed application UI RCL + AutoForge.Components/ Generic, reusable status/notification component + AutoForge.Core/ Platform-neutral target-kind descriptors + AutoForge.Application/ Inward-dependent target-selection feature + tests/ + AutoForge.UnitTests/ + AutoForge.IntegrationTests/ +``` + +## Development and prerequisites + +Prerequisites for this Windows-first Client build: + +- .NET SDK **10.0.402**, or a later stable patch in the same **10.0.4xx** feature + band, as pinned in [global.json](global.json). +- Installed `maui-windows` workload (10.0.110 workload manifest) and Windows SDK + target **10.0.26100.0**. +- Windows x64 runtime target and Microsoft Edge WebView2 Runtime. Native smoke + verification used WebView2 **155.0.4283.62**. +- nuget.org access for package restore. + +No automotive driver, vehicle, model, backend or cloud account is required. +Other Windows, macOS, Android or iOS targets are not configured or verified. + +From the repository root in PowerShell, restore and build the actual native +framework/runtime target: + +```powershell +dotnet restore .\src\AutoForge.Client\AutoForge.Client.csproj --runtime win-x64 +dotnet restore .\src\AutoForge.slnx +dotnet build .\src\AutoForge.Client\AutoForge.Client.csproj --configuration Release --no-restore --framework net10.0-windows10.0.26100.0 +dotnet build .\src\AutoForge.slnx --configuration Release --no-restore +dotnet test .\src\tests\AutoForge.UnitTests\AutoForge.UnitTests.csproj --configuration Release --no-build +dotnet test .\src\tests\AutoForge.IntegrationTests\AutoForge.IntegrationTests.csproj --configuration Release --no-build +``` + +Start the application on a Windows desktop: + +```powershell +dotnet run --project .\src\AutoForge.Client\AutoForge.Client.csproj --framework net10.0-windows10.0.26100.0 +``` + +There is no backend or browser/server startup command. Headless UI/application +integration tests run independently of the native Client; they render the real +RCL components/routes and compose the actual application registration. + +## Documentation and handoff + +- [Documentation index](docs/README.md) +- [Current project graph and UI architecture](docs/architecture.md) +- [Original foundation ADR and its superseded decision](docs/adr-0001-headless-foundation.md) +- [Single-shell and feature-slice ADR](docs/adr-0002-single-shell-vsa.md) +- [Build, test and native smoke guide](docs/build-and-test.md) +- [Step-01 historical report](prompts/Step-01-Report.md) +- [Step-01A assignment](prompts/Step-01A.md) and + [Step-01A worker report](prompts/Step-01A-Report.md) +- [Orchestrator-owned roadmap](prompts/ROADMAP.md) and + [orchestration state](prompts/STATE.md) + +Handoffs are manual. Worker completion does not mean orchestrator acceptance or +authorize the held Step-02. diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..035881d --- /dev/null +++ b/docs/README.md @@ -0,0 +1,21 @@ +# AutoForge documentation + +The implemented scope is the accepted Step-01 foundation plus the Step-01A +Windows-first MAUI Blazor Hybrid shell, two RCLs and metadata-selection UI. +Vehicle diagnostics, simulation and operation capabilities remain planned. + +- [Architecture](architecture.md): actual seven-project graph, Client/UI/RCL + ownership, feature-slice organization and explicit target-selection contract. +- [ADR-0001: Headless .NET 10 foundation](adr-0001-headless-foundation.md): + historical foundation decisions, with its dual-shell/deferred-host decision + explicitly superseded. +- [ADR-0002: Single native shell and feature slices](adr-0002-single-shell-vsa.md): + current one-Client/two-RCL/modular-monolith architecture. +- [Build and test](build-and-test.md): SDK/MAUI/Windows/WebView2 prerequisites, + exact commands, rendered/native verification, evidence and limitations. + +See the [root README](../README.md) for product vision and implementation status, +the [roadmap](../prompts/ROADMAP.md) for future milestones, the +[Step-01 historical report](../prompts/Step-01-Report.md), and the +[Step-01A worker report](../prompts/Step-01A-Report.md) for execution evidence. +Manual acceptance remains the orchestrator's responsibility. diff --git a/docs/adr-0001-headless-foundation.md b/docs/adr-0001-headless-foundation.md new file mode 100644 index 0000000..1464520 --- /dev/null +++ b/docs/adr-0001-headless-foundation.md @@ -0,0 +1,55 @@ +# ADR-0001: Headless .NET 10 foundation and explicit targets + +- Date: 2026-10-28 +- Status: foundation decisions retained; host-timing decision superseded by [ADR-0002](adr-0002-single-shell-vsa.md) +- Scope: repository and application foundation only + +## Context + +This ADR records the original 2026-10-28 Step-01 foundation decision, before the +owner's later architectural realignment. At that time the repository contained +only its product vision and ignore rules, and the planned hosts were standalone +Blazor WebAssembly plus Windows-first MAUI Blazor Hybrid. The dual-host and +deferred-host decision is historical and is explicitly superseded by ADR-0002; +the platform-neutral foundation, explicit-target and honest-error decisions +remain in force. + +## Decision + +1. Use .NET 10/C# with a single solution under `src`, Core and Application + libraries, and unit/integration test projects under `src/tests`. Keep technical + documentation in `docs` and manual handoffs in `prompts`. +2. Keep Core platform-neutral and dependency-free. Application depends inward on + Core, with only the DI abstractions needed for its composition extension. + The concrete DI container belongs only to integration tests in this step. +3. Implement a genuine metadata-selection use case first. Each request supplies + its provider identifier and defined target kind. Never infer a kind, default + a provider or fall back between simulation, replay and physical hardware. + Snapshot registrations, reject ambiguity, and return explicit failures. +4. Do not equate metadata with connection, capability or authorization. Add no + transport, driver, command sender, write operation or real provider. +5. **Superseded by ADR-0002:** stage both standalone WASM and Windows-first MAUI + Hybrid until Step-05. The owner instead requires one initial Windows-first + MAUI Blazor Hybrid Client and two purposeful UI/Components RCLs now. +6. Use the installed .NET 10.0.402 SDK with stable, same-feature-band patch + roll-forward only, centralized direct package pins and one VSTest/xUnit stack. + Run real tests, without hardware/cloud dependencies. + +## Consequences + +- At the time of this decision there was no interactive application startup + command; Step-01A subsequently adds the actual native Client. +- The original four purposeful projects are retained and extended by Step-01A + with Client/UI/Components. +- Synthetic metadata tests prove selection semantics and actual DI composition, + not simulation, replay, diagnostics or physical device availability. +- Feature-organized Application and UI slices can consume the resolver without + owning domain truth. An isolated simulation oracle must not leak into UI paths. +- Initial future hardware integration is read-only. Physical programming requires + separate authorization/evidence; no selection or simulation approval grants it. +- Test tooling uses the SDK's xUnit v2 template family. v2 remains maintained for + critical fixes, while new framework features are developed in v3. A future + framework migration should be deliberate, not mix VSTest and MTP accidentally. + +See the [current architecture](architecture.md), [ADR-0002](adr-0002-single-shell-vsa.md) +and [build/test policy](build-and-test.md) for current composition and verification. diff --git a/docs/adr-0002-single-shell-vsa.md b/docs/adr-0002-single-shell-vsa.md new file mode 100644 index 0000000..5f1e6d4 --- /dev/null +++ b/docs/adr-0002-single-shell-vsa.md @@ -0,0 +1,68 @@ +# ADR-0002: One native shell, two RCLs, feature-oriented application + +- Date: 2026-10-28 +- Status: implemented for Step-01A; manual orchestrator acceptance pending +- Supersedes: ADR-0001's dual-shell and deferred-host decision only +- Scope: initial application composition and organization + +## Context + +The accepted Step-01 foundation provides real, headless Core/Application +target-selection behavior and regression tests, but no host or UI. The owner +subsequently realigned the architecture before the held Step-02: add a usable +Windows-first native application now, keep work in-process and use vertical +feature slices without unnecessary hosting/infrastructure layers. Preserve the +accepted target-selection feature and every original regression behavior. + +## Decision + +1. The sole initial application executable is **AutoForge.Client**, a .NET 10 + MAUI Blazor Hybrid app initially targeting Windows x64. +2. **AutoForge.UI**, a `net10.0` RCL, owns the complete application routes, pages, + navigation, layout and feature presentation. **AutoForge.Components**, a + separate `net10.0` RCL, owns generic reusable controls. +3. Use exactly the primary production dependency path + `Client -> UI -> Components`. UI calls application contracts; Client composes + the real existing Application feature in-process. Dependencies on Application + needed for composition/presentation are direct; neither UI nor Client is + substituted by a web/server host. +4. Preserve Core as platform-neutral and organize Application behavior by cohesive, + independently testable feature slices. The existing target selection lives at + `Features/ExecutionTargets/SelectExecutionTarget` without changing its public + namespace or wrapping it in mediator/handler boilerplate. +5. Headless unit/integration tests compile and render Components/UI/Application + independently of MAUI. The native Client references those same real RCLs and + application registration; tests do not mock the feature/component under test. +6. Initial routes are `/` (foundation), `/execution-targets` (explicit metadata + selection), and an explicit not-found presentation. Selection requires a + provider identifier and defined kind, resolves only registered metadata, and + never means connection, capability or operation authorization. +7. Keep the application startable without backend, database, vehicle, native + driver, model, cloud account or service. The Client registers an empty real + provider list; the UI communicates `ProviderNotRegistered` explicitly rather + than fabricating a connected provider. +8. Add future features only when assigned and owned: domain engines remain + independent, slices coordinate their relevant use cases, and additional + processes/hosts require a concrete requirement and approval. + +## Consequences + +- The four original Core/Application/test projects and all 54 accepted tests are + retained. The solution now contains seven projects including the one native + executable and two purposeful RCLs. +- A MAUI Windows workload, Windows SDK and WebView2 runtime are real native build/ + run prerequisites. RCL compilation and headless tests do not substitute for + native Client build/smoke evidence. +- The standalone Blazor WebAssembly plus MAUI Hybrid dual-shell plan and Step-05 + host deferral recorded in ADR-0001 are superseded; ADR-0001's platform-neutral + foundation, dependency direction, explicit target and no-fallback decisions + remain valid. +- No empty automotive feature directory, simulation/diagnostic/AI service, server + process, database, cloud service, generic manager/repository layer or mediator + is introduced. +- Future simulation remains deterministic and AI-independent with isolated + verification. Future initial hardware integration is read-only; neither + selection nor simulated approval grants physical write authority. + +See the [implemented architecture](architecture.md) and +[build/test policy](build-and-test.md) for source paths and concrete evidence. diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 0000000..a9ebc4d --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,108 @@ +# Implemented architecture + +## Application shape + +AutoForge is an in-process modular monolith with exactly one application +executable: the Windows-first MAUI Blazor Hybrid Client. The application uses +Razor component libraries for the complete routed UI and generic shared controls. +There is no web/server host, WASM host or backend process. + +```mermaid +flowchart TD + Client[AutoForge.Client: MAUI startup, BlazorWebView and DI] --> UI[AutoForge.UI: routes and feature presentation] + UI --> Components[AutoForge.Components: reusable generic UI] + UI --> Application[AutoForge.Application: cohesive feature slices] + Client --> Application + Application --> Core[AutoForge.Core: platform-neutral contracts] + UnitTests[AutoForge.UnitTests] --> Components + UnitTests --> Core + IntegrationTests[AutoForge.IntegrationTests] --> UI + IntegrationTests --> Application + IntegrationTests --> Core +``` + +## Projects and dependency boundaries + +All seven projects are in [AutoForge.slnx](../src/AutoForge.slnx): + +| Project | Target and responsibility | Project references | +|---|---|---| +| [Core](../src/AutoForge.Core/AutoForge.Core.csproj) | `net10.0`; platform-neutral explicit target-kind and immutable descriptor invariants | None | +| [Application](../src/AutoForge.Application/AutoForge.Application.csproj) | `net10.0`; in-process application use cases, organized by feature | Core | +| [Components](../src/AutoForge.Components/AutoForge.Components.csproj) | `net10.0` RCL; generic `StatusNotice` with accessible tone and safe text rendering | None | +| [UI](../src/AutoForge.UI/AutoForge.UI.csproj) | `net10.0` RCL; all application routes, navigation, layout and presentation | Application, Components | +| [Client](../src/AutoForge.Client/AutoForge.Client.csproj) | `net10.0-windows10.0.26100.0`; only MAUI Blazor Hybrid application executable | Application, UI | +| [UnitTests](../src/tests/AutoForge.UnitTests/AutoForge.UnitTests.csproj) | `net10.0`; descriptor/resolver and rendered generic component tests | Application, Components, Core | +| [IntegrationTests](../src/tests/AutoForge.IntegrationTests/AutoForge.IntegrationTests.csproj) | `net10.0`; real DI, rendered RCL, application and actual project-graph tests | Application, Components, Core, UI | + +Components has no AutoForge project dependency. UI never references Client. +Core and Application never reference UI/Components/Client or tests. There are no +cycles or production-to-test edges. Tests render UI directly and never reference +or launch Client. + +The Client contains only MAUI lifecycle/startup, its Windows platform entry +point, the `BlazorWebView`, host HTML/CSS and in-process composition. It registers +an empty target metadata set deliberately, so the real selection use case reports +not-registered until an explicit future composition supplies real metadata. +No fake connected/available provider is added. + +## UI ownership and real routes + +All Razor routes and layouts are owned by the UI RCL; `Routes` scans the UI +assembly, not the native Client assembly. + +| Route | UI owner | Implemented behavior | +|---|---|---| +| `/` | `Features/Foundation/Home.razor` | Describes the current foundation and accurately distinguishes implemented from absent features | +| `/execution-targets` | `Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor` | Requires explicit provider identifier and target kind, calls the real injected application resolver and displays success/errors | +| Any unmatched route | `Features/Foundation/NotFoundPage.razor` via UI `Routes.razor` | Presents an explicit not-found page and supported navigation | + +`Layout/MainLayout.razor` supplies main navigation, shared layout and a permanent +metadata-only limitation statement. The generic +[StatusNotice](../src/AutoForge.Components/StatusNotice.razor) is shared by the +home, target-selection and not-found pages; isolated CSS bundles from both RCLs +are imported through the Client scoped-style bundle. + +The target-selection page's feature-local `ExecutionTargetSelectionViewModel` +adapts explicit input to the existing Application resolver. It contains only +presentation state/input validation and expected error display; it does not +reimplement provider resolution. It receives the actual `IExecutionTargetResolver` +through DI. The same `AddAutoForgeTargetSelection` registration used in the +headless integration tests is composed by Client. + +## Application feature organization + +The accepted target-selection use case is grouped under +`Application/Features/ExecutionTargets/SelectExecutionTarget/`; its original +public namespace and API remain unchanged. Core still owns +`Simulation`, `RecordedReplay`, `PhysicalHardware` and immutable target descriptor +invariants. Application snapshots registrations, rejects duplicate IDs using +ordinal case-insensitive comparison, resolves only exact requested metadata and +returns the registered descriptor. Existing typed failures and no-fallback +behavior remain unchanged. + +New use cases should be cohesive and independently testable slices. Each slice +owns its request/coordination and relevant application contract without forcing +unrelated projects to depend on Application. Domain engines/protocols remain +platform-neutral and can be extracted only when a real boundary warrants it. +Do not add mediator boilerplate, generic manager/repository layers or empty +future slices to demonstrate architecture. + +## Honest limitations and safety boundaries + +Current work implements application-shell/navigation behavior, accessible status +presentation and **metadata selection only**. It does not implement vehicle +profiles, connection/discovery, simulation, diagnostics, telemetry, replay, +backups, calibration, persistence, AI, cloud services, operation execution or +hardware integration. Physical-kind metadata neither connects nor grants a +capability/write approval. + +Future simulation remains deterministic and AI-independent with an isolated +verification oracle. Future initial hardware integration is read-only. Physical +programming requires separate operation-specific authorization and evidence. +These are architectural requirements, not current app behavior. + +The original [ADR-0001](adr-0001-headless-foundation.md) preserves valid foundation +decisions but marks its dual-shell/deferred-host decision superseded. +[ADR-0002](adr-0002-single-shell-vsa.md) is the current host and feature-slice +decision. diff --git a/docs/build-and-test.md b/docs/build-and-test.md new file mode 100644 index 0000000..6c7c3c6 --- /dev/null +++ b/docs/build-and-test.md @@ -0,0 +1,94 @@ +# Build and test + +## Prerequisites + +- Windows x64, .NET SDK 10.0.402 with its approved .NET 10 patch roll-forward. +- Windows 10 SDK 10.0.26100.0 and the MAUI Windows workload (10.0.110). +- Microsoft Edge WebView2 Runtime for launching the native Blazor Hybrid Client. + +The Client targets `net10.0-windows10.0.26100.0` and `win-x64`. The Core, +Application, UI, Components and test projects target portable `net10.0`. Headless +tests therefore do not require MAUI or WebView2. The solution uses centralized +package versions; change direct dependencies only through the central package +file and validate the resulting restore. + +## Restore and build + +From the repository root in PowerShell: + +```powershell +dotnet restore .\src\AutoForge.slnx +dotnet build .\src\AutoForge.slnx --configuration Release +``` + +For an explicit Windows runtime pack restore or native Client build: + +```powershell +dotnet restore .\src\AutoForge.Client\AutoForge.Client.csproj --runtime win-x64 +dotnet build .\src\AutoForge.Client\AutoForge.Client.csproj --configuration Release --framework net10.0-windows10.0.26100.0 --no-restore +``` + +Run the app on Windows: + +```powershell +dotnet run --project .\src\AutoForge.Client\AutoForge.Client.csproj --configuration Release --framework net10.0-windows10.0.26100.0 +``` + +The app is a native MAUI window containing the actual `AutoForge.UI` routes in a +BlazorWebView. Its initial provider registration is empty by design. Startup and +selection remain useful to exercise the honest `ProviderNotRegistered` result; +they do not require a backend, a database or vehicle hardware. + +## Automated verification + +Run the focused portable suites: + +```powershell +dotnet test .\src\tests\AutoForge.UnitTests\AutoForge.UnitTests.csproj --configuration Release +dotnet test .\src\tests\AutoForge.IntegrationTests\AutoForge.IntegrationTests.csproj --configuration Release +``` + +Unit tests cover Core/Application behavior and rendered reusable components. +Integration tests cover actual dependency-injection composition, rendered UI +routes with the real Application resolver, and the project-reference graph. +`ProjectGraphTests` reads the project manifests; it guards the production +dependency direction rather than relying on a diagram. + +At Step-01A implementation verification, the full Release solution build and the +direct native Client build completed with zero warnings and errors. The portable +suite results were 39 unit tests and 26 integration tests passed (65 total). +All 54 Step-01 tests remain in the expanded suites. + +## Native smoke checks + +Run the Client on Windows and verify: + +1. The native window opens with the AutoForge home route and no unhandled-error + banner. +2. Navigation reaches `/execution-targets` and displays the explicit + `ProviderNotRegistered` empty-provider state. +3. The UI states that selection is metadata-only and does not connect to a + vehicle or authorize operations. +4. Submitting a valid, explicit provider identifier and defined target kind + returns the honest not-registered result; it does not fall back to another + kind or invent a provider. +5. An unmatched path displays the explicit not-found presentation. +6. Components RCL scoped-style assets load in the WebView. + +Automated rendered-route tests cover the route/component/Application behavior; +they are not evidence of native WebView startup. Record the native Client build, +window, route interactions and style asset verification separately in the +Step-01A execution report. + +## Guardrails and limitations + +- Selection is explicit registered **metadata** only. It is not a connection, + detected capability, health result or authorization. +- The Client's empty provider registry is deliberate. Do not add a fabricated + provider to make the screen look populated. +- No HTTP server, browser-only host, database, cloud service, simulation engine, + diagnostic engine or hardware driver is part of this foundation. +- Keep the native Client dependency and platform surface isolated; preserve + portable testability for UI, Components, Application and Core. +- Step-02 remains held for orchestrator acceptance; completing this build guide + does not authorize later roadmap work. diff --git a/global.json b/global.json new file mode 100644 index 0000000..c591544 --- /dev/null +++ b/global.json @@ -0,0 +1,7 @@ +{ + "sdk": { + "version": "10.0.402", + "rollForward": "latestPatch", + "allowPrerelease": false + } +} diff --git a/prompts/ROADMAP.md b/prompts/ROADMAP.md index dd721ac..08bcb7d 100644 --- a/prompts/ROADMAP.md +++ b/prompts/ROADMAP.md @@ -3,12 +3,16 @@ ## Status and authority - Initialized: 2026-10-28. -- Current phase: initial orchestration; no application functionality exists yet. -- Active assignment: [Step-01](Step-01.md), ready for manual worker execution. -- Last accepted step: none. +- Current phase: corrected single-shell foundation accepted; profile/module work next. +- Active assignment: [Step-02](Step-02.md), regenerated for manual worker execution. +- Last accepted step: Step-01A, accepted 2026-10-28 after implementation/evidence review. +- Outstanding corrections: none. +- Step-02 status: READY FOR WORKER; explicitly supersedes its unexecuted pre-correction version. - Current state and handoff: [STATE.md](STATE.md). -- Authority: the supplied master charter, as superseded by the repository - structure and agent handoff amendment. The amendment's naming and layout win. +- Authority: the master charter, repository/handoff amendment, and the owner's + 2026-10-28 architectural realignment. The latest decision cancels the dual-shell + requirement and adopts one MAUI Blazor Hybrid executable plus vertical slices. + The amendment's layout, naming, protected files and manual workflow still apply. - This document describes the intended architecture and future capabilities. Planned projects, interfaces, milestones, and demonstrations are not claims of implemented or verified functionality. @@ -68,38 +72,74 @@ prompt/report naming convention. ## Architecture baseline -### Initial physical projects +### Existing accepted foundation, preserved -Step-01 creates only four projects: +Step-01 established four projects, all preserved by Step-01A. Their current references: | Project | Responsibility | Allowed project references | |---|---|---| | `src/AutoForge.Core` | Platform-neutral foundational value types, invariants, and shared contracts | None | | `src/AutoForge.Application` | Use-case coordination and application-facing services; initially explicit execution-target selection | Core | -| `src/tests/AutoForge.UnitTests` | Focused domain and application behavior tests | Core, Application | -| `src/tests/AutoForge.IntegrationTests` | Real application composition and cross-project behavior, without hardware/cloud | Core, Application | +| `src/tests/AutoForge.UnitTests` | Domain/application behavior and rendered generic component tests | Core, Application, Components | +| `src/tests/AutoForge.IntegrationTests` | Real application/RCL composition and project-graph tests, without hardware/cloud | Core, Application, Components, UI | -This is deliberately a headless foundation. It must include real behavior and -tests, not empty assemblies or always-passing test placeholders. Application -shells arrive in Step-05 when working services can support them. This is staging, -not a substitution for either required shell. +The original foundation was headless. Accepted Step-01A added Client/UI/Components +without discarding these projects or their 54 cases. The solution now has seven +projects and 65 worker-verified tests (39 unit, 26 integration). The old deferred +dual-host plan remains canceled. + +### Corrected application architecture + +AutoForge is a **modular monolith** with **Vertical Slice Architecture** for +application use cases. Its sole initial application executable is +`src/AutoForge.Client`, a .NET 10 MAUI Blazor Hybrid application, initially Windows. +Simulation, diagnostics, calibration and AI services can run in-process. No +standalone WebAssembly shell, separate web application, or backend executable is +required. Additional processes/hosts need a concrete requirement and an approved +decision; do not scaffold speculative alternatives. + +Accepted Step-01A established: + +| Project | Responsibility | Allowed project references | +|---|---|---| +| `src/AutoForge.Client` | Thin native MAUI startup, lifecycle, configuration, BlazorWebView hosting and DI/platform composition | UI, Application and justified platform adapters; no test projects | +| `src/AutoForge.UI` | Complete application routes, pages, navigation, layouts, feature presentation and interaction workflows | Components, Application/contracts and justified domain contracts; never Client | +| `src/AutoForge.Components` | Generic reusable status controls, inputs, gauges/charts/layout building blocks as actually needed | Framework UI dependencies; no UI, Client, hardware or application feature implementation | + +Primary UI direction: **Client -> UI -> Components**. The shell contains only +platform/bootstrap code, not routed application pages, business workflows, +diagnostic protocols or simulation algorithms. Application UI lives in the UI RCL; +vehicle-independent reusable widgets live in Components. No circular references. + +Application remains necessary and owns the working target-selection slice at +`Features/ExecutionTargets/SelectExecutionTarget`, with its public namespace +preserved. Future slices group operations +under actual feature areas such as Vehicles, Diagnostics, Simulation, Calibration, +Telemetry and AI. Do not create their empty directories now. Slice-local request, +handler/service, validation and result types are added only when useful. +MediatR, generic repositories/managers and uniform boilerplate are not required. + +UI feature presentation follows the same feature areas where practical; it calls +application contracts without duplicating business validation. Reusable engines, +protocols, calibration and telemetry capabilities remain independently testable +libraries, extracted only when needed. They must not depend on UI, Client or the +application slice that coordinates them. Do not force all technical libraries to +reference Application. ### Planned boundaries, added only when used | Boundary / likely project | Responsibilities and dependency direction | |---|---| | Core | Vehicle/module identities, capability states, provenance, units, versioned domain schemas; no UI, inference, transport implementation, or storage dependencies | -| Application | Diagnostic use cases, provider selection, calibration/runbook validation, approval, execution coordination, application ports; depends on Core | -| Diagnostics | Addressing, protocol/service handling, decoding, transport interfaces and communication trace; depends on Core and only needed Application contracts | +| Application | Feature/use-case slices coordinating reusable capabilities; existing target selection retained; depends inward on domain and needed capability abstractions | +| Diagnostics | Addressing, protocol/service handling, decoding, transport interfaces and communication trace; depends on domain/transport abstractions, not UI or coordinating slices | | Simulation | Virtual clock, coupled dynamics, virtual modules, simulated transport, deterministic faults; depends on shared contracts/Diagnostics, never on an LLM or UI | | Persistence / telemetry infrastructure | Recording, replay, calibration/version storage, audit and knowledge repositories implementing application ports; introduce a project only when justified | -| AI / knowledge integration | Provider adapters, research and retrieval, schema-constrained planning; consumes restricted application query/planning ports, never hardware-driver access | -| Hardware adapter | Verified OBDX Pro GT/native integration behind shared diagnostic ports; Windows-specific code isolated from browser/shared UI | -| Shared UI components RCL | Data-driven gauges, charts, controls, layouts; consumes platform-neutral view models/contracts | -| Shared application screens RCL | Profile, diagnostics, simulation, calibration, replay, knowledge, AI, settings screens; composes components and calls application services | -| Standalone Blazor WebAssembly shell | Browser composition, routing and shared RCL hosting; no native driver references | -| MAUI Blazor Hybrid shell | Windows-first native composition hosting the same RCLs; platform services injected at the host boundary | -| Local .NET hardware service | Browser-to-native bridge when needed; explicit authorization and local exposure controls, not a required cloud backend | +| AI / knowledge integration | In-process replaceable inference/research/retrieval capabilities behind restricted planning contracts; no arbitrary hardware-driver access | +| Hardware adapter | Verified OBDX Pro GT/native integration behind shared diagnostic ports; Windows-specific integration composed by Client and isolated from reusable UI | +| AutoForge.Components | Generic data-bound gauges, charts, controls and status/layout components, introduced only as used | +| AutoForge.UI | Application feature pages/routes/navigation/layouts; composes Components and calls application features | +| AutoForge.Client | Sole initial executable: Windows-first MAUI Blazor Hybrid, thin startup/lifecycle/BlazorWebView and in-process DI composition | These are logical responsibilities, not an instruction to create all assemblies now. Keep related responsibilities together until an actual dependency or @@ -109,23 +149,24 @@ Planned dependency flow: ```mermaid flowchart TD - Browser[Standalone Blazor WebAssembly] --> Screens[Shared screens RCL] - Hybrid[MAUI Blazor Hybrid] --> Screens - Screens --> Components[Shared components RCL] - Screens --> App[Application use cases and ports] - AI[Local AI and knowledge adapters] --> App + Client[AutoForge.Client - MAUI Blazor Hybrid] --> UI[AutoForge.UI - application RCL] + UI --> Components[AutoForge.Components - reusable RCL] + Client --> App[Application feature slices] + UI --> App App --> Core[Core domain and contracts] - Sim[Simulation and virtual modules] --> Ports[Diagnostic and application ports] - Store[Recording and persistence adapters] --> Ports - Native[Native hardware adapter] --> Ports - Bridge[Local hardware service] --> App - Ports --> Core + App --> Capabilities[Reusable simulation / diagnostics / calibration / telemetry / AI capabilities] + Capabilities --> Core + Client --> Native[Platform adapters] + Native --> Ports[Appropriate shared capability ports] App --> Ports + Ports --> Core ``` Ports in the diagram are logical contracts, not an additional required project. -Composition roots wire implementations. Dependency injection does not grant AI -or UI unrestricted programming authority. +Client is the native composition root; headless tests compose application services +without Client. Capabilities in this diagram are logical responsibilities, not +instructions to create all assemblies. Dependency injection does not grant AI or +UI unrestricted programming authority. ### Invariants @@ -181,18 +222,22 @@ or UI unrestricted programming authority. ## Milestones and acceptance gates -All milestones below are unimplemented. Only Step-01 is currently assigned. +Step-01 and its owner-directed correction Step-01A are accepted. Step-02 has been +regenerated from the corrected seven-project implementation and is the only +active assignment. Its old unexecuted version is explicitly superseded. +All Step-02 and later product capabilities remain unimplemented. Dependencies indicate acceptance prerequisites, not permission for automatic handoff. Later assignments refine these scopes using actual implementation evidence; they must not silently discard required capabilities. | Step | Milestone | Depends on | Status | Principal acceptance gate | |---|---|---|---|---| -| 01 | Repository and solution foundation | Repository inspection | READY FOR WORKER | Four-project .NET 10 foundation, explicit target-selection behavior, real unit/integration tests, successful recorded build/test evidence, accurate README and architecture docs | -| 02 | Vehicle profiles and module model | 01 accepted | PLANNED | Versioned profile round trips, validation, extensible module inventory, identity/applicability and explicit capability states; clearly synthetic vehicle fixture | +| 01 | Repository and solution foundation | Repository inspection | ACCEPTED 2026-10-28 | Four-project .NET 10 foundation, explicit target-selection behavior, real unit/integration tests, successful recorded build/test evidence, accurate README and architecture docs | +| 01A | Single-shell and vertical-slice architectural correction | 01 accepted; owner realignment | ACCEPTED 2026-10-28 | Seven-project Client -> UI -> Components foundation; preserved Core/Application; 65 passing cases and successful solution/native build/startup reported; corrected ADR/docs inspected | +| 02 | Vehicle profiles and module model | 01A accepted; assignment regenerated | READY FOR WORKER | Versioned profile round trips, validation, extensible modules/capabilities/provenance, exact configuration selection, synthetic fixtures and a minimal metadata-only UI feature using application slices | | 03 | Virtual modules and diagnostic communication | 02 | PLANNED | Application discovers/identifies synthetic modules and reads telemetry/DTCs through a simulated transport; trace, negative responses and deterministic timeout tests | | 04 | Deterministic vehicle dynamics | 03 | PLANNED | Coupled engine/transmission/road-load model, virtual clock and lifecycle controls; identical scenarios/inputs reproduce outputs under a documented numerical contract | -| 05 | Both application shells and live dashboard | 04 | PLANNED | Standalone WASM and Windows MAUI Hybrid share two logical RCLs; select a profile, control simulation and display independently collected live telemetry | +| 05 | Live dashboard in the established Client/UI/Components architecture | 04; accepted 01A foundation | PLANNED | Feature pages select a profile, control simulation and display independently collected live telemetry through reusable Components; no new application host | | 06 | Telemetry recording and replay | 05 | PLANNED | Persist raw messages and decoded signals with metadata; playback/seek/speed controls feed the same gauges without silently reconstructing missing data | | 07 | Calibration management and simulated programming | 06 | PLANNED | Versioned definitions/diffs, verified baseline and backup, approved simulated write, readback/unrelated-data checks, audit and supported restore; no physical writes | | 08 | Local AI, knowledge, and validated runbooks | 07 | PLANNED | Replaceable local inference, applicable knowledge retrieval, structured logical runbook, independent validation/approval and simulation-only execution | @@ -211,7 +256,14 @@ evidence; they must not silently discard required capabilities. ### Scope details for Steps 02-10 -- **02:** vehicle specifications and configuration/tune selection, arbitrary module +- **01A accepted prerequisite:** one thin MAUI Client, two RCLs, feature-organized + target selection, actual headless rendered tests and worker native build/smoke + evidence. All 54 original cases remain in the expanded 65-case suites. +- **02:** the regenerated assignment explicitly supersedes the earlier unexecuted + version. Organize profile load/select/import/export as cohesive application + slices with reusable Core contracts. Add only a thin profile metadata page in + the existing UI, using those same services; no host restructuring or new engine. + Retain vehicle specifications and configuration/tune selection, arbitrary module identities, supported/unsupported/unknown/inaccessible/restricted capability states, firmware/calibration identity, relationships, provenance, validation, schema versioning, and multiple synthetic variants. Never imply a diagnostic @@ -226,11 +278,12 @@ evidence; they must not silently discard required capabilities. throttle/load/torque/fuel, transmission/shift scheduling, mass/drivetrain/road load, temperatures, and a stationary-to-45-MPH-to-stop scenario with a five-minute hold. Report mathematical assumptions and repeatability tolerances. -- **05:** reusable data-bound gauges and feature screens, navigation and settings, - profile/module selection, connection state and diagnostics; compile-time feature - composition first, no unsupported arbitrary assembly loading. Missing MAUI - workloads are blockers, not permission to replace either shell. Native browser - access eventually uses a verified local .NET service, never browser P/Invoke. +- **05:** extend the already established UI feature pages with reusable data-bound + gauges, settings, profile/module selection, connection state and diagnostics. + Client remains thin; application slices coordinate in-process capabilities. + Use ordinary packaged RCL/feature composition, not unsupported arbitrary assembly + loading. Missing MAUI workloads are blockers, not permission to substitute a + WebAssembly/web host. Native adapters do not require a separate backend. - **06:** versioned recording format, module/source/units/time/quality metadata, raw plus decoded retention, interrupted/corrupt session handling, replay play/pause/stop/restart/seek/navigation/speed. Acquisition must not depend on @@ -264,8 +317,9 @@ Steps 11-20 retain richer gauges/clusters/charts and dashboard editing, comparis and analysis, more vehicle/module/protocol coverage, independently validated research, curated datasets, advanced dynamics and transmission modeling, local model evaluation/specialization, authorized programming, and supported release -packaging. New MAUI platforms require platform-specific evidence. Avalonia is an -optional feasibility investigation, not a promise that Razor embeds unchanged. +packaging. New MAUI platforms require platform-specific evidence. Additional +hosts, including any Avalonia investigation, require a concrete use case and +approval; none are currently required or to be scaffolded speculatively. Optional MCP does not bypass runbook safety. Firmware emulation is separate from the initial behavioral simulator, never an implied capability of synthetic modules. @@ -320,6 +374,10 @@ not proven real-world economy improvements. Missing prerequisites or unexecuted tests are BLOCKED/NOT EXECUTED, never PASSED. - Every assignment requires appropriate real unit/integration tests, documentation and README review. No empty "integration" tests or success-shaped placeholders. +- RCL and application feature tests must run independently of MAUI. Native Client + build/startup evidence remains separate; headless tests cannot prove BlazorWebView + integration or satisfy a missing workload. Document exact native prerequisites + and successful/failed/not-executed checks without architectural substitution. - The orchestrator inspects evidence without claiming independent runtime execution. ## Decisions, completed work, remaining work, and blockers @@ -328,8 +386,8 @@ not proven real-world economy improvements. - D-001: amendment layout and Step-XX naming supersede the original examples. - D-002: one .NET 10 solution; minimal headless Core/Application foundation first. -- D-003: standalone WASM plus Windows-first MAUI Hybrid, shared components/screens; - no Blazor Server substitution. +- D-003 (SUPERSEDED 2026-10-28): the previous dual-shell/deferred-host decision is + retained as history only. It is canceled by D-009/D-010 below. - D-004: common diagnostic/application interfaces across simulation, replay and physical providers; explicit execution target, no fallback. - D-005: deterministic simulation and independent verification are prerequisites @@ -339,6 +397,18 @@ not proven real-world economy improvements. - D-007: initial hardware is read-only; bench and vehicle writes have separate authorization/evidence gates and retain prohibited-operation restrictions. - D-008: handoffs remain manual; only the worker builds/tests and implements. +- D-009: sole initial executable AutoForge.Client, .NET 10 MAUI Blazor Hybrid, + initially Windows; complete UI in AutoForge.UI RCL and generic widgets in + AutoForge.Components RCL. No required WebAssembly/web/backend executable. +- D-010: modular monolith with application Vertical Slice Architecture; UI -> + application contracts, Client -> composition; engines/protocols remain independent. + Retain existing Application immediately and organize its actual use case by feature. +- D-011: Step-01A corrects the accepted foundation before Step-02. Do not rewrite + the final Step-02 until 01A is implemented, reviewed and accepted; regenerate it + using actual results and explicitly supersede the old unexecuted assignment. +- D-012: with 01A accepted, Step-02 adds a minimal metadata-only profile consumer + to the existing UI alongside headless feature services. This advances one + cohesive profile slice, not the later simulator/dashboard milestone. The worker records the relevant accepted decisions as technical ADRs when creating or changing the implementation. Future changes require a reason and roadmap/state @@ -348,17 +418,61 @@ history, not repeated redesign without evidence. - Read both supplied instruction sets and inspected the existing repository. - Established the initial planned boundaries, sequence, and first worker assignment. +- Accepted Step-01 after reviewing the assignment, report, all production/test + source, project/configuration files, root-file diffs and documentation. +- Confirmed immutable target descriptors, explicit/no-fallback resolution, eager + DI validation, snapshot isolation, and the intended four-project dependency graph. +- Reviewed worker evidence: .NET SDK 10.0.402, successful Release build with zero + warnings/errors, 35 unit plus 19 integration tests passed, zero failed/skipped. + Source case counts and existing restore/Release outputs corroborated the report; + the orchestrator did not run application builds or tests. +- Prepared [Step-02](Step-02.md) under the prior architecture; it was not executed. + It was held during correction and is now superseded by the regenerated version. +- At correction planning, inspected the then-four-project solution: there were + no obsolete hosts to delete; the missing UI foundation and obsolete plans/docs + were assigned rather than discarding useful code. +- Adopted the new single-shell/RCL/vertical-slice decisions and prepared + [Step-01A](Step-01A.md). +- Accepted Step-01A after inspecting shell bootstrap, RCL route/component ownership, + feature code, all affected tests, project/package graph, documentation and ADRs. + Worker evidence records successful seven-project Release/native builds with + zero warnings/errors, 39 unit + 26 integration cases passed, zero failed/skipped, + and actual Windows home/selection/not-found and RCL asset smoke observations. +- Static source counts, seven-project acyclic references, restored assets and + native/portable Release outputs corroborate the report. The orchestrator did + not execute application builds/tests or native startup. +- Regenerated Step-02 against that accepted implementation, with explicit + supersession, feature/RCL boundaries, regressions and worker verification duties. ### Remaining -- All application implementation, build/test verification, and technical - documentation work, beginning with Step-01. -- Review Step-01 and any corrections before issuing Step-02. +- Worker execution of Step-02, then manual acceptance review and any Step-02A + corrections before Step-03. +- All profile/module and later product capabilities remain planned. Preserve the + complete sequence and safety gates rather than restarting or reducing scope. ### Known blockers and uncertainties -No confirmed initialization blocker. The orchestrator has not inspected installed -.NET SDKs, workloads, package compatibility, inference availability, or hardware. -The worker must inspect prerequisites; absence of evidence is not compatibility. -Physical hardware access, applicable manufacturer definitions, and programming -authorization are future gates, not current claims. +No blocking architectural/native verification deficiency remains for Step-02. +The Step-01A report records SDK 10.0.402, runtime 10.0.13, Windows target +10.0.26100.0/win-x64, MAUI Windows manifest 10.0.110 and WebView2 155.0.4283.62. +Native execution is worker evidence, not an orchestrator rerun. Other platforms, +inference and automotive hardware remain unverified. + +Non-blocking deviations are retained explicitly: + +- The worker mistakenly invoked workload restore during inspection, reported + manifest updates (workload version 10.0.403 and iOS/MacCatalyst changes), stopped + the action and did not roll back. Required Windows manifest remained 10.0.110; + final Windows builds/tests/smoke passed according to the report. Broader + environment impact is unverified. This is not retroactive authorization. + Do not repeat workload-changing commands or attempt rollback without approval. +- Raw Git whitespace checking flags README CRLF against the mixed-line-ending + tracked baseline. There are no trailing spaces/tabs; a command-local + CR-at-EOL-aware check passes. Step-02 must normalize the already-to-be-updated + Markdown to the existing LF editor convention without changing Git settings. +- README/ADR acceptance-pending lifecycle text is accurate as of worker report + creation; Step-02 must align it with this acceptance while preserving history. + +No major environment installation, update, repair or rollback is automatically +authorized. Physical definitions/access and programming approval remain future gates. diff --git a/prompts/STATE.md b/prompts/STATE.md index a7d8771..ae815fa 100644 --- a/prompts/STATE.md +++ b/prompts/STATE.md @@ -5,18 +5,19 @@ | Field | Value | |---|---| | Updated | 2026-10-28 | -| Phase | Initial orchestration complete; application foundation not started | -| Active step | Step-01 - Repository and solution foundation | -| Assignment | [Step-01.md](Step-01.md) | +| Phase | Corrected single-shell foundation accepted; vehicle profile slice next | +| Active step | Step-02 - Vehicle profiles and control module model | +| Assignment | [Step-02.md](Step-02.md), regenerated after Step-01A acceptance | | Assignment status | READY FOR WORKER / AWAITING MANUAL HANDOFF | -| Expected worker report | `prompts/Step-01-Report.md` - not yet created | -| Last accepted step | None | +| Expected worker report | `prompts/Step-02-Report.md` - not yet created | +| Last accepted step | Step-01A - accepted 2026-10-28 | | Outstanding corrections | None | -| Worker execution | Not invoked; user controls handoff | -| Immediate next action | User manually directs the worker to execute Step-01 only | +| Step-02 status | READY FOR WORKER; old unexecuted assignment explicitly superseded | +| Worker execution | Step-01A manually completed; Step-02 not invoked | +| Immediate next action | User manually directs the worker to execute regenerated Step-02 only | | Next orchestrator action | After manual return, inspect the assignment, report, implementation, tests, Git changes, documentation and recorded command evidence | -## Repository baseline +## Repository baseline at initialization - Repository: `D:\_Repos\Code\GAJ3T\AutoForge`. - Branch observed: `main`, tracking `origin/main`. @@ -30,8 +31,8 @@ Step-01 requires preserving it while making implementation status explicit. - Existing `.gitignore` already includes common Visual Studio/.NET build patterns. Worker must extend only where necessary and preserve existing entries. -- Orchestrator changes are limited to `prompts/ROADMAP.md`, this file, and - `prompts/Step-01.md`. Existing tracked files and Git metadata are preserved. +- Initial orchestrator changes were limited to `prompts/ROADMAP.md`, this file, + and `prompts/Step-01.md`. Step-01 subsequently added the implementation below. ## Architecture decisions in force @@ -40,52 +41,168 @@ See [ROADMAP.md](ROADMAP.md) for the full planned architecture and milestones. 1. The repository has only three top-level project directories: `docs`, `src`, `prompts`; existing protected infrastructure is preserved. Tests are under `src/tests`. No root `tests`, root `artifacts`, or nested `AutoForge` directory. -2. The worker creates `src/AutoForge.slnx` targeting .NET 10. Initial production - projects are Core and Application; initial test projects are UnitTests and - IntegrationTests. No unused placeholder assemblies. -3. Step-01 is headless with real target-selection validation and composition tests. - Simulation/diagnostics are introduced in Steps 02-04; both required UI shells - and shared components/screens RCLs are introduced in Step-05. -4. Domain logic is platform-neutral. Application use cases depend inward on Core. - Hardware, inference, storage, and UI implementations never own domain truth. -5. Simulation, replay, and physical hardware targets are explicit and cannot +2. Keep the existing single `src/AutoForge.slnx`, Core, Application, UnitTests and + IntegrationTests. Accepted target-selection code/tests remain useful. +3. Sole initial application executable: AutoForge.Client, .NET 10 MAUI Blazor + Hybrid, initially Windows. No required standalone WebAssembly/web shell or + separate backend. Ordinary desktop capabilities run in-process as a modular + monolith; additional hosts/processes need a concrete approved requirement. +4. Accepted Step-01A established Client -> UI -> Components. Client is thin native startup, + BlazorWebView and DI/lifecycle/platform composition. UI owns complete routes, + pages, navigation/layouts and feature presentation. Components owns generic + reusable controls. UI cannot reference Client; Components cannot reference UI. +5. Application is needed now and retained. Organize use cases into cohesive feature + slices, beginning with existing execution-target selection. No mediator, + generic repository/manager layer, prescribed boilerplate or empty future slices. + UI invokes application contracts; business logic stays outside Razor components. +6. Reusable domain, simulation, diagnostic, calibration, telemetry and AI capability + libraries remain independently testable and are added only when justified. + They do not depend on Client/UI or their coordinating application slices. + Hardware, inference, storage and UI implementations never own domain truth. +7. Simulation, replay, and physical hardware targets are explicit and cannot silently substitute for one another. Selection is not connection or execution. -6. Synthetic data is labeled; simulation is deterministic and independent of AI, +8. Synthetic data is labeled; simulation is deterministic and independent of AI, and verification uses an isolated oracle unavailable to ordinary UI/AI paths. -7. AI plans are validated runbooks; no arbitrary hardware commands or offsets. +9. AI plans are validated runbooks; no arbitrary hardware commands or offsets. Local inference is replaceable; core operation does not require AI/cloud. -8. Initial hardware integration is read-only. Simulated approval, physical +10. Initial hardware integration is read-only. Simulated approval, physical capability discovery, and driver availability cannot authorize physical writes. Bench and vehicle programming require separate future authorization/evidence. -9. All handoffs are manual. Orchestrator never invokes the worker, implements +11. All handoffs are manual. Orchestrator never invokes the worker, implements application changes, or executes application builds/tests. -10. The worker does not change the roadmap, state, or assignment; it may write only +12. The worker does not change the roadmap, state, or assignment; it may write only the current assignment's report under `prompts`. No automatic commits/pushes. -## Prerequisites and known issues +## Historical Step-01 acceptance review -- The worker must inspect installed SDKs, templates and package compatibility - before choosing exact versions. .NET 10 compatibility is not yet verified. +Decision at that review: **ACCEPTED**, 2026-10-28, with no identified blocking +defect under the then-current architecture. This acceptance and its evidence +remain historical facts. The later owner decision now requires Step-01A before +progression; it does not erase the accepted implementation or its reports. + +Reviewed [Step-01](Step-01.md), the [worker report](Step-01-Report.md), all seven +production source files, all three test source files, four project files, solution, +five root configuration files, README/ignore diffs and all four technical documents. +The source enforces explicit identity/kind selection, case-insensitive uniqueness, +no cross-target fallback, immutable descriptors and registration snapshots. +Integration tests exercise the real DI/Core/Application path rather than mocks. + +| Criterion | Decision | Evidence | +|---|---|---| +| AC-01 | ACCEPTED | Expected README/ignore changes only among pre-existing implementation files; empty index; original assignment/roadmap/state hashes matched the report before orchestration updates; protected instructions absent | +| AC-02 | ACCEPTED | Actual root project directories are docs/src/prompts; tests under src/tests; no root tests/artifacts or nested repository | +| AC-03 | ACCEPTED | Inspected solution and all project references: Core has none; Application -> Core; both test projects -> Core/Application; all net10.0 | +| AC-04 | ACCEPTED | Inspected SDK policy, nullable/build/editor settings, central package pins and assets; worker records installed SDK 10.0.402 and actual VSTest execution | +| AC-05 | ACCEPTED | Descriptor/resolver/DI source satisfies explicit validation, uniqueness, snapshot and no-fallback requirements; no production provider is fabricated | +| AC-06 | ACCEPTED | All composition tests inspected; real container/service path covers positive selection and empty/invalid/mismatched/duplicate cases | +| AC-07 | ACCEPTED ON WORKER EXECUTION EVIDENCE | Reported final Release build: zero warnings/errors; unit 35/35, integration 19/19, zero failures/skips; source case counts and existing restore/Release outputs corroborate the report | +| AC-08 | ACCEPTED | Documentation index, architecture/error contract/Mermaid, ADR, build/test guide and README describe actual scope and planned features accurately | +| AC-09 | ACCEPTED | No operational hardware/AI/UI dependency or extra placeholder project; no automatic handoff introduced | +| AC-10 | ACCEPTED | Complete report contains exact command outcomes, corrected failures, acceptance mapping and required sections in one plain copy window; no later implementation present | + +Worker-reported execution: Windows x64, SDK 10.0.402, runtime 10.0.13; +restore, Release build and both suites succeeded after the documented +repository-local NuGet feed correction. Reported total: 54 passed, zero failed, +zero skipped. Existing assets confirm the framework/dependency graph; Release +binaries exist for all four projects. Their presence is corroboration, not an +independent test execution. + +The orchestrator executed only read-only inspection and document/Git checks, +including static test-case counting and ignore-policy checks. It did **not** +execute dotnet, application builds, tests, formatting or hardware operations. +Runtime results are explicitly worker evidence. The worker's original report and +assignment remain unchanged; implementation is not committed by this review. + +## Owner architectural realignment and current inspection + +On 2026-10-28 the owner canceled the two-shell plan, required Client/UI/Components +and application Vertical Slice Architecture, and directed correction before +Step-02. [Step-01A](Step-01A.md) was the corrective assignment and is now accepted. + +At correction planning, inspection found the original four-project solution unchanged: +Core has no dependencies, Application references Core and DI abstractions, and +both tests reference Core/Application. The existing target resolver and eager +registration are suitable for a feature slice and must be preserved. + +There was no host/component implementation to delete or migrate. Correction was +additive UI composition plus feature organization, not a repository restart. +The old Step-02 was held, not executed. + +After acceptance, [Step-02](Step-02.md) was regenerated from the seven-project +implementation and explicitly supersedes the prior unexecuted assignment. It now +uses application feature slices, reusable Core models and a thin profile metadata +consumer in the existing UI. No Step-02 implementation/report exists yet. + +## Step-01A acceptance review + +Decision: **ACCEPTED**, 2026-10-28. No Step-01B assignment is required. + +Reviewed the [assignment](Step-01A.md), [worker report](Step-01A-Report.md), +solution and all project references, Client native/bootstrap/host code, RCL routes, +feature pages/view model/component/styles, moved Application feature, new rendered/ +graph tests, package/build configuration, README and all affected technical docs. + +| Criterion | Decision | Evidence | +|---|---|---| +| AC-01 | ACCEPTED | Existing descriptor/resolver semantics and 54 prior cases retained; expanded suites contain 39 unit/26 integration cases; root layout/history/manual workflow preserved | +| AC-02 | ACCEPTED | Actual seven-project solution, one production executable, MAUI/Windows Client configuration and native Release output | +| AC-03 | ACCEPTED | MainPage hosts UI Routes through BlazorWebView; UI owns routes/layout/pages, Components owns StatusNotice; native route/assets observations reported | +| AC-04 | ACCEPTED | Project files, graph test and independent static traversal confirm Client -> UI -> Components, allowed Application references and no cycles | +| AC-05 | ACCEPTED | Feature folder contains real resolver/DI/errors with stable public namespace and unchanged explicit selection/snapshot/no-fallback behavior | +| AC-06 | ACCEPTED | Actual HtmlRenderer component/route tests use real Core/Application DI, cover errors/unknown routes and safe text rendering, without Client references | +| AC-07 | ACCEPTED ON WORKER EXECUTION EVIDENCE | Reported complete Release solution and direct Windows Client builds: zero warnings/errors; 39 unit plus 26 integration passed, zero failed/skipped; matching source counts and Release outputs inspected | +| AC-08 | ACCEPTED ON WORKER NATIVE EVIDENCE | Detailed reported native home/selection/unregistered-physical/not-found checks, hidden error banner and both RCL CSS assets loading; native executable exists, not rerun by orchestrator | +| AC-09 | ACCEPTED | README/index/architecture/build guide and ADR-0001/0002 reflect one shell, two RCLs, VSA/modular monolith and metadata-only limitations | +| AC-10 | ACCEPTED | Evidence-bearing report, corrected failures and environment deviation disclosed; historical reports/assignments preserved and Step-02 unexecuted | + +Worker-reported verified platform: SDK 10.0.402, runtime 10.0.13, Windows +10.0.26100.0/win-x64, MAUI Windows manifest 10.0.110 and WebView2 155.0.4283.62. +The source counts, framework/assets, seven-project graph and native/portable +Release artifacts corroborate the report. They do not prove an independent +runtime run. No application builds/tests/native launch were performed here. + +Acceptance covers the application correction, not approval of the unintended +workload action or a claim that the broader tool environment is unchanged. +The deviations below are non-blocking for this verified Windows foundation and +must remain visible. No environment rollback or source fix was attempted. + +## Prerequisites, limitations, and known issues + +- Step-01A worker evidence establishes portable and native Windows compatibility + for the accepted foundation. Recheck prerequisites if the environment changes. - No major SDK/workload/driver installation has been authorized. Report exact missing prerequisites and mark blocked checks honestly; do not replace .NET 10 - or either required UI architecture. -- Step-01 does not need MAUI workloads, an AI model, containers, a vehicle, a - native driver, or cloud infrastructure. -- No confirmed implementation defects or environmental blockers are known because - there is no implementation yet. + MAUI Blazor Hybrid with a web host. +- Reported workload incident: `dotnet workload restore` was mistakenly invoked + during inspection, began manifest updates and was stopped. Worker reports + workload version 10.0.403 and newer iOS/MacCatalyst manifests; Windows manifest + stayed 10.0.110. No rollback occurred. Final Windows checks passed, but broader + impact is unverified. Do not repeat workload-changing commands or repair/rollback + without explicit authorization; this review does not authorize them. +- Raw `git diff --check` failed on README CRLF, against a mixed-line-ending index. + Read-only byte inspection found 151 CRLF lines and no trailing spaces/tabs. + A command-local CR-at-EOL-aware check passed, with no Git configuration changed. + Require LF normalization during Step-02's already-required README update. +- README/ADR acceptance-pending text is historical to worker completion; Step-02 + must align lifecycle statements while preserving original reports/decisions. +- No blocking Step-02 prerequisite is currently identified. +- Simulation, replay, diagnostics, profiles, telemetry, calibration, persistence, + AI and hardware operations remain unimplemented; only foundation UI is present. - No application build or test has been executed by the orchestrator. ## Review and progression gate -On manual return, evaluate every Step-01 acceptance criterion using the original +On manual return, evaluate every Step-02 acceptance criterion using the original assignment, worker report, actual code/tests, dependency graph, Git changes, README/docs, and recorded build/test evidence. Do not accept solely on a success claim; do not claim independent runtime verification. -- If accepted: record the decision and evidence, update roadmap/state, create - `Step-02.md`, and stop for manual handoff. -- If deficient: create `Step-01A.md` with measurable corrections, update state, - and stop. Further corrections use `Step-01B.md`, etc., with matching reports. +- Inspect domain/schema invariants, feature organization, profile UI/application + tests, all regressions, native profile smoke evidence and documentation. +- If accepted: record the decision, update roadmap/state, create Step-03 and stop + for manual handoff. Do not execute it. +- If deficient: create `Step-02A.md` with measurable corrections and matching + report requirements, update state, and stop. Do not advance to Step-03. - If blocked: retain the active step, document the prerequisite and required worker evidence; do not advance or mark unexecuted checks as successful. - Never create the next major assignment while acceptance or corrections are open. @@ -96,10 +213,20 @@ claim; do not claim independent runtime verification. |---|---|---| | 2026-10-28 | Initial repository inspection | Clean `main`; only root README and ignore file tracked; no application or protected instruction files found | | 2026-10-28 | Initial roadmap, state, and Step-01 prepared | Amendment layout/naming adopted; READY FOR WORKER, no implementation accepted | +| 2026-10-28 | User returned Step-01 for review | Original assignment, worker report, code/tests, configuration, Git changes and documentation inspected | +| 2026-10-28 | Step-01 ACCEPTED | No blocking deficiency; worker evidence reports successful Release build and 54 passed, zero failed/skipped tests; no orchestrator runtime execution | +| 2026-10-28 | Step-02 prepared | Profile/module model, versioned JSON, synthetic fixtures and application selection; manual worker handoff pending | +| 2026-10-28 | Owner architecture decision superseded the dual-shell plan | One MAUI Client, UI/Components RCLs, vertical-slice modular monolith; Step-01 acceptance preserved but corrective 01A required | +| 2026-10-28 | Existing solution re-inspected | Only four headless projects; no obsolete hosts to delete; no application changes/builds/tests executed | +| 2026-10-28 | Step-01A prepared; Step-02 placed on hold | Correction is ready for manual worker execution; old Step-02 body retained, final regeneration deferred until correction acceptance | +| 2026-10-28 | Step-01A returned and ACCEPTED | Seven-project single-shell/RCL/VSA implementation inspected; worker reports successful solution/native builds, 65 passing cases and native route/asset checks | +| 2026-10-28 | Deviations recorded | Unintended workload manifest updates disclosed; no rollback; README CRLF-only diff hygiene noted for next documentation update | +| 2026-10-28 | Step-02 regenerated | Explicitly supersedes unexecuted pre-correction version; actual seven-project baseline and profile feature/UI scope; READY FOR WORKER | ## Manual handoff instruction -Provide [Step-01.md](Step-01.md) to the separate worker and request execution of -that assignment only. The worker must produce `prompts/Step-01-Report.md` and stop. +Provide regenerated [Step-02.md](Step-02.md) to the separate worker and request +execution of that assignment only. The worker must produce +`prompts/Step-02-Report.md` and stop. Return manually to the orchestrator for review. Reports, including final chat reports, must follow the single plain triple-backtick copy-window requirement. diff --git a/prompts/Step-01-Report.md b/prompts/Step-01-Report.md new file mode 100644 index 0000000..1c615c9 --- /dev/null +++ b/prompts/Step-01-Report.md @@ -0,0 +1,402 @@ +``` +# Step-01 worker report + +## 1. Step identifier and title + +Step-01 - Repository and solution foundation. +Establish the .NET 10 repository, headless application foundation, real tests, +and truthful developer documentation. + +Execution date: 2026-10-28. Role: worker. Only Step-01 was executed. + +## 2. Completion status + +COMPLETE - worker implementation and required verification succeeded. +Manual orchestrator review/acceptance is pending; this is not an acceptance claim. +All AC-01 through AC-10 are mapped below. No required check is blocked or skipped. + +## 3. Implemented functionality + +- Platform-neutral, immutable execution-target metadata for Simulation, + RecordedReplay and PhysicalHardware. +- Descriptor construction rejects null/blank/padded identifiers and all undefined + kinds, including zero/default. Both identifier and kind must be explicit. +- Provider identifiers use ordinal case-insensitive comparison without trimming + or culture-sensitive normalization; original registered spelling is preserved. +- The resolver returns the exact registered descriptor only when both the + requested identifier and kind match. +- Missing selections, unknown registrations, duplicates/casing ambiguity, and + kind mismatches fail explicitly. No guessed default or cross-target fallback. +- Private snapshotting isolates validated registrations from caller collection + mutation. Sealed, get-only descriptors cannot be mutated through the public API. +- Ordinary Microsoft.Extensions DI composition validates eagerly at setup. + Repeated resolver setup is rejected instead of silently replacing the registry. +- Empty production-like registration is valid but every selection reports + ProviderNotRegistered. Production code supplies no synthetic or real providers. + +Selection is metadata only: no connection, availability, discovery, execution, +read/write capability or approval is asserted. All test metadata is synthetic. + +## 4. Files created + +25 new files, including this report. All remain unstaged/uncommitted. + +Root configuration (5): +- [.editorconfig](../.editorconfig) +- [global.json](../global.json) +- [Directory.Build.props](../Directory.Build.props) +- [Directory.Packages.props](../Directory.Packages.props) +- [NuGet.Config](../NuGet.Config) + +Solution and projects (5): +- [src/AutoForge.slnx](../src/AutoForge.slnx) +- [AutoForge.Core.csproj](../src/AutoForge.Core/AutoForge.Core.csproj) +- [AutoForge.Application.csproj](../src/AutoForge.Application/AutoForge.Application.csproj) +- [AutoForge.UnitTests.csproj](../src/tests/AutoForge.UnitTests/AutoForge.UnitTests.csproj) +- [AutoForge.IntegrationTests.csproj](../src/tests/AutoForge.IntegrationTests/AutoForge.IntegrationTests.csproj) + +Production source (7): +- [ExecutionTargetKind.cs](../src/AutoForge.Core/ExecutionTargets/ExecutionTargetKind.cs) +- [ExecutionTargetDescriptor.cs](../src/AutoForge.Core/ExecutionTargets/ExecutionTargetDescriptor.cs) +- [IExecutionTargetResolver.cs](../src/AutoForge.Application/ExecutionTargets/IExecutionTargetResolver.cs) +- [ExecutionTargetResolver.cs](../src/AutoForge.Application/ExecutionTargets/ExecutionTargetResolver.cs) +- [TargetSelectionFailure.cs](../src/AutoForge.Application/ExecutionTargets/TargetSelectionFailure.cs) +- [TargetSelectionException.cs](../src/AutoForge.Application/ExecutionTargets/TargetSelectionException.cs) +- [ServiceCollectionExtensions.cs](../src/AutoForge.Application/ExecutionTargets/ServiceCollectionExtensions.cs) + +Tests (3): +- [ExecutionTargetDescriptorTests.cs](../src/tests/AutoForge.UnitTests/ExecutionTargetDescriptorTests.cs) +- [ExecutionTargetResolverTests.cs](../src/tests/AutoForge.UnitTests/ExecutionTargetResolverTests.cs) +- [TargetSelectionCompositionTests.cs](../src/tests/AutoForge.IntegrationTests/TargetSelectionCompositionTests.cs) + +Technical documentation (4): +- [docs/README.md](../docs/README.md) +- [docs/architecture.md](../docs/architecture.md) +- [docs/adr-0001-headless-foundation.md](../docs/adr-0001-headless-foundation.md) +- [docs/build-and-test.md](../docs/build-and-test.md) + +Worker handoff (1): +- [Step-01-Report.md](Step-01-Report.md) + +Template Class1 and UnitTest1 files were removed before validation. They were +newly generated, not deletions of pre-existing tracked implementation. + +## 5. Files modified and preservation evidence + +Only two pre-existing files changed: +- [README.md](../README.md): preserved the complete original product description, + labeled it as vision, and added truthful scope, prerequisites and documentation. +- [.gitignore](../.gitignore): retained existing entries; appended seven lines + for local environment secrets, a visible .env.example exception, and ignored + src/local-data/ for private captures/firmware/models. + +Baseline Git status was clean. Five tracked files were present: these two root +files and the three orchestration documents. No concurrent changes were observed +or discarded. No staging, Git initialization, commits, pushes or Git configuration +changes were performed. + +The assignment, roadmap and state were read in full and preserved. SHA-256 values +recorded before implementation matched afterward: + +| Protected file | Unchanged SHA-256 | +|---|---| +| Step-01.md | D7412E8F47BCDE11E9F6902E35455CC3F6D3BF60AD2D334B093C4575FF8C0C90 | +| ROADMAP.md | F9E1B12C78D0C8FC6D5BD83007B9C71F4CF2FC841CB5ED2D664375736A0EC78C | +| STATE.md | 0BD016FFE478B2EC9B2C577E0C04E4F85FD9F93D26F24F1FA3D0C7BDFDB8E2E6 | + +No applicable AGENTS.md existed in the repository or its ancestor locations. +.github/copilot-instructions.md was absent and remains absent. No replacement +instruction file was created. Git diffs for protected documents and the index +were empty, exit 0. + +Final pre-report inventory: two modified tracked files and 24 intended untracked +files; this report is the 25th new file. Untracked source was explicitly listed. +No credentials, private captures, firmware or model assets were introduced. + +## 6. Architecture and actual dependency graph + +All four projects target net10.0. Actual project-reference queries confirmed: + +| Project | Project references | Direct production infrastructure package | +|---|---|---| +| Core | None | None | +| Application | Core | Microsoft.Extensions.DependencyInjection.Abstractions | +| UnitTests | Core, Application | Not a production project | +| IntegrationTests | Core, Application | Concrete DI container only in tests | + +Application -> Core; UnitTests -> Application/Core; +IntegrationTests -> Application/Core. No production-to-test dependency exists. + +Core owns the validated descriptor and target-kind invariant. Application owns +resolution, typed selection/ambiguity exceptions and DI registration. +Invalid inputs use standard argument exceptions with parameter names. +TargetSelectionException exposes ProviderNotRegistered, KindMismatch or +DuplicateProviderIdentifier for application failures. Duplicate detection happens +at resolver construction/DI extension invocation, before container building. + +Get-only descriptors and a private dictionary form the mutation boundary. +One identifier names one kind, including across case variants. Registration +requires a single deliberate setup call; no plugin framework/service locator. + +Actual top-level directories: .git (preserved metadata), docs, prompts, src. +The only project directories are docs, src and prompts. Tests are under src/tests. +No root tests, root artifacts, nested AutoForge project directory or nested +src/.git was present. No future-feature placeholder directories were created. + +Both eventual Blazor hosts and shared components/screens RCLs are staged for +Step-05, not replaced by another architecture. No host exists in Step-01. + +## 7. Unit tests created and behavior coverage + +35 discovered/passed cases in two real Core/Application test classes: + +| Test group / method | Cases | Behavior | +|---|---:|---| +| Descriptor: Constructor_PreservesExplicitIdentifierAndKind | 3 | All defined kinds, exact input metadata | +| Descriptor: Constructor_RejectsNullIdentifier | 1 | Null identifier and parameter name | +| Descriptor: Constructor_RejectsBlankOrPaddedIdentifier | 5 | Empty, whitespace, leading/trailing whitespace | +| Descriptor: Constructor_RejectsUndefinedKind | 4 | Negative, default, out-of-range and maximum integer | +| Resolver: Resolve_ReturnsExactRegisteredDescriptor | 3 | Same registered object for each kind | +| Resolver: Resolve_UsesOrdinalCaseInsensitiveIdentifiers | 1 | Case-insensitive lookup preserves registered casing | +| Resolver: Resolve_DoesNotUseCultureSensitiveIdentifierComparison | 1 | Dotless-i lookalike is not substituted | +| Resolver: Resolve_RejectsMissingSelection | 1 | Null request fails explicitly | +| Resolver: Resolve_EmptyRegistryReportsNotRegistered | 3 | No fabricated availability for any kind | +| Resolver: Resolve_UnknownIdentifierDoesNotSelectAnotherProviderOfSameKind | 1 | No same-kind default/fallback | +| Resolver: Resolve_RejectsEveryKindMismatchWithoutFallback | 6 | All ordered cross-kind mismatches; another matching-kind provider cannot substitute | +| Resolver: Constructor_RejectsDuplicateIdentifiersRegardlessOfKind | 3 | Exact/case-ambiguous duplicates, including across kinds | +| Resolver: Constructor_SnapshotsCallerCollection | 1 | Clear/replace/add duplicates after construction cannot change validated metadata | +| Resolver: Constructor_RejectsNullRegistrations | 1 | Null collection rejected | +| Resolver: Constructor_RejectsNullDescriptor | 1 | Null entry rejected | + +No placeholder tests, mocks of the use case, skipped cases or zero-discovery +projects are used. + +## 8. Integration tests created and actual boundary coverage + +19 discovered/passed cases in TargetSelectionCompositionTests. Every selection +uses the application service obtained through the actual DI extension/container. + +| Method | Cases | Real boundary exercised | +|---|---:|---| +| Composition_ResolvesExactExplicitSyntheticMetadata | 3 | Real Core validation, registration, container and exact descriptor identity/kind | +| Composition_EmptyProductionLikeRegistryIsUnavailable | 3 | Empty composition fails for every target kind | +| Composition_MismatchDoesNotSelectOtherProvider | 3 | Physical/simulation/replay mismatch despite alternative metadata | +| Composition_DuplicatesFailAtRegistrationBeforeContainerBuild | 2 | Same/cross-kind casing ambiguity fails eagerly, leaving services unchanged | +| Composition_CallerMutationBeforeContainerBuildCannotChangeRegistry | 1 | DI setup snapshot survives list replacement/ambiguity before container build | +| Composition_RejectsRepeatedSetupRatherThanSilentlyReplacingResolver | 1 | Repeated registration fails; original service behavior remains | +| Composition_RejectsMissingSelectionThroughResolvedService | 1 | Missing selection through actual resolved service | +| Composition_RejectsInvalidIdentifierAtSelectionBoundary | 2 | Invalid identifier cannot enter the composed use case | +| Composition_RejectsUndefinedKindAtSelectionBoundary | 1 | Omitted/default kind cannot enter the composed use case | +| Composition_RejectsNullRegistrationsWithoutAddingServices | 1 | Invalid setup is explicit and atomic | +| Composition_RejectsNullServiceCollection | 1 | Invalid composition argument is explicit | + +The registry is in-memory metadata, not simulated hardware. Physical-kind +descriptors have no connection/write-approval fields or operational services. +These tests do not claim device integration evidence. + +## 9. Environment, packages and runner + +Inspected dotnet --info, dotnet --list-sdks, dotnet new list, +dotnet new xunit --help and dotnet new sln --help before scaffolding. +The installed templates explicitly support net10.0 and slnx. + +| Item | Observed/selected | +|---|---| +| OS | Windows, version 10.0.26200 | +| RID / execution architecture | win-x64 / x64 | +| Installed and selected SDK | 10.0.402 | +| MSBuild | 18.9.15+a8dd0577c | +| Used Microsoft.NETCore.App host/runtime | 10.0.13, x64 | +| Target/configuration | net10.0 / Release, all four projects | +| SDK policy | 10.0.402, latestPatch, allowPrerelease=false | +| Runner | VSTest, SDK default; no MTP opt-in | + +The SDK policy permits later stable patches only within 10.0.4xx, not other +feature bands or major versions. dotnet --version after configuration returned +10.0.402. No SDK, workload, driver or model installation was performed. + +Package versions were checked against public nuget.org version indexes and +nuspec dependency/framework groups before final dependency changes: + +| Package | Requested/resolved version | Compatibility evidence | +|---|---|---| +| Microsoft.Extensions.DependencyInjection.Abstractions | 10.0.14 | net10.0 dependency group; Application restore/build succeeded | +| Microsoft.Extensions.DependencyInjection | 10.0.14 | net10.0 group, matching abstractions; real container tests succeeded | +| Microsoft.NET.Test.Sdk | 18.11.0 | net8.0 test-host assets usable from net10.0; both suites discovered/executed | +| xunit | 2.9.3 | Framework family/version supplied by installed .NET 10 xUnit template; actual net10.0 execution | +| xunit.runner.visualstudio | 4.0.1 | Metadata explicitly supports xUnit v1/v2/v3 and .NET 8+; actual net10.0 execution | + +Both test projects use identical central test package pins. The official xUnit +v2 package guidance states critical-fix maintenance continues, while new features +are developed in v3: https://xunit.net/docs/nuget-packages-v2 . +This is a supported maintenance-framework choice, not a claim that v2 is the +newest framework. No incompatible MTP/VSTest combination was added. +The unused template coverage collector was removed. + +dotnet list .\src\AutoForge.slnx package --no-restore confirmed all exact direct +versions above and no packages in Core. Per-project dotnet msbuild queries for +TargetFramework, Nullable, ImplicitUsings and TreatWarningsAsErrors returned +net10.0, enable, enable and true for every project. + +NuGet.Config selects only public nuget.org at repository scope. Shared props +enable nullable references, implicit usings, deterministic builds and warnings +as errors. Editor conventions use CRLF for code/config and LF for Markdown. + +## 10. Exact restore/build commands and results + +Commands were run from D:\_Repos\Code\GAJ3T\AutoForge in PowerShell. + +| Command | Execution/result | +|---|---| +| dotnet restore .\src\AutoForge.slnx | Initial exit 1: NU1507 treated as error because two inherited package feeds were configured with central package management | +| dotnet restore .\src\AutoForge.slnx | After repository NuGet.Config: exit 0, all four projects restored, no warnings/errors emitted | +| dotnet build .\src\AutoForge.slnx --configuration Release --no-restore | Initial post-restore build: exit 0, 0 warnings, 0 errors; 3.05 seconds | +| dotnet build .\src\AutoForge.slnx --configuration Release --no-restore | Final post-source-format build: exit 0, 0 warnings, 0 errors; 0.58 seconds | + +Meaningful initial failure: "NU1507: Warning As Error: There are 2 package sources +defined in your configuration. When using central package management, map your +package sources ... or specify a single package source." +Resolved at repository scope without suppressing warnings or modifying +user/machine feeds. No restore/build failure remains. + +Scaffolding used dotnet new sln --format slnx and net10.0 classlib/xunit templates +with --no-restore; dotnet sln add and dotnet add reference established the graph. +All scaffolding/reference commands succeeded. No manual solution format invention. + +Formatting commands both exited 0: +- dotnet format whitespace .\src\AutoForge.slnx --no-restore --verbosity minimal +- dotnet format whitespace .\src\AutoForge.slnx --no-restore --verify-no-changes --verbosity minimal + +Solution membership: dotnet sln .\src\AutoForge.slnx list, exit 0, exactly four +expected projects. + +## 11. Exact test command and per-project results + +dotnet test .\src\AutoForge.slnx --configuration Release --no-build + +Executed twice: after the initial successful build and after C# formatting/final +build. Both invocations exited 0 with identical counts. No runner adaptation. + +Final measured output: + +| Project | Discovered/total | Passed | Failed | Skipped | Runner duration | +|---|---:|---:|---:|---:|---| +| AutoForge.UnitTests (net10.0) | 35 | 35 | 0 | 0 | 24 ms | +| AutoForge.IntegrationTests (net10.0) | 19 | 19 | 0 | 0 | 31 ms | +| Total | 54 | 54 | 0 | 0 | Not a deterministic performance claim | + +Each project's output identified .NETCoreApp,Version=v10.0 and one matched test +assembly. No zero-discovery project, necessary skipped test or failed case. +No retained TRX was requested/generated. These durable counts and command results +are evidence; the temporary prerequisite tool output was removed after recording +its values, and this report does not depend on an ephemeral log path. + +## 12. Acceptance verification + +| ID | Status | Concrete evidence | +|---|---|---| +| AC-01 | PASSED | Initial clean status; only README/ignore modified among prior tracked files; protected hashes and Git diffs unchanged; index empty; no init/commit/push | +| AC-02 | PASSED | Actual root directories .git/docs/prompts/src only; tests under src/tests; prohibited root/nested paths absent | +| AC-03 | PASSED | slnx membership lists exactly four projects; per-project reference queries and MSBuild property inspection confirm net10.0 and inward graph | +| AC-04 | PASSED | Installed/selected SDK 10.0.402, runtime 10.0.13 x64; shared nullable/editor/build settings; central compatible pins and actual VSTest execution | +| AC-05 | PASSED | Core descriptor plus Application resolver/DI snapshot enforce explicit identity/kind, every mismatch, missing/unknown/duplicate errors and mutation isolation; 35 unit cases | +| AC-06 | PASSED | 19 real DI-based cases cover all target kinds, empty/invalid/mismatched/duplicate configuration and selection, without mocking the service | +| AC-07 | PASSED | Successful restore and final Release build, 0 build warnings/errors; both suites executed with 35/19 passed and 0 failed/skipped | +| AC-08 | PASSED | Four actual docs include index, architecture/Mermaid/error contract, ADR and exact build/testing policy; README distinguishes implemented/in-progress/planned | +| AC-09 | PASSED | Actual project/package graph has no operational/UI/AI/hardware dependency; no fake production providers, host substitution, automatic handoff or placeholder project | +| AC-10 | PASSED | This exact Step-01-Report.md contains the required evidence/sections inside one plain copy window; worker stops without advancing | + +## 13. Documentation changes + +Created the documentation index, actual dependency/Mermaid architecture and +failure contract, foundation ADR, and build/test guide. They document eager +registration validation, immutable snapshots, identifier comparison, package/SDK +policy, exact commands, test boundaries and current limitations. + +Future read-only hardware and AI-independent deterministic simulation/oracle +boundaries are recorded as requirements, not implemented capabilities. Both +future Blazor hosts/shared RCLs are explicitly preserved. + +## 14. Root README changes + +Changed: YES. Original product description retained verbatim as product vision. +Added IMPLEMENTED, IN PROGRESS and PLANNED sections; explicit Step-01 manual +acceptance status; actual graph/layout, SDK policy and exact commands; real +documentation links; headless test entry point; no interactive startup command; +and explicit absence of simulation/diagnostics/backups/AI/UI/hardware operations. + +## 15. Known limitations + +- Metadata selection only; no real providers, discovery, connections, capability + inspection, operations or approval service. +- Simulation, replay, diagnostics, profiles, telemetry, calibration, backups, + persistence, AI, UI and hardware programming remain unimplemented. +- No real vehicle, native driver, MAUI host or model was used or verified. +- Core/Application are platform-neutral, but runtime verification is Windows x64 + only. No cross-platform or UI build is claimed. +- xUnit v2 is critical-fix maintained, not the newest framework feature line. +- Direct dependency pins are centralized; no transitive lock file, offline + package mirror or coverage percentage is claimed. +- Initial restore needs nuget.org access; the use case/tests need no network, + hardware, wall-clock input, randomness or AI service. +- Manual acceptance is pending. No later assignment has been started. + +## 16. Outstanding issues, failures, warnings and unexecuted scope + +No blocking prerequisite, unresolved implementation defect or required failed/ +unexecuted check remains. + +Corrected execution/inspection issues: +1. Initial restore failed NU1507, exit 1; repository-local single-source + NuGet.Config fixed it. Subsequent restore/build/test succeeded. +2. Exploratory dotnet list .\src\AutoForge.slnx reference reported + "Project `.\src\AutoForge.slnx` is invalid." This reference subcommand did not + accept the solution path; it was not a solution build failure. Its individual + exit was not captured in that exploratory batch (the later package query + made the batch exit 0). Corrected per-project reference queries all exited 0: + - dotnet list .\src\AutoForge.Core\AutoForge.Core.csproj reference + - dotnet list .\src\AutoForge.Application\AutoForge.Application.csproj reference + - dotnet list .\src\tests\AutoForge.UnitTests\AutoForge.UnitTests.csproj reference + - dotnet list .\src\tests\AutoForge.IntegrationTests\AutoForge.IntegrationTests.csproj reference +3. Auxiliary Git whitespace check returned exit 2 after trying CRLF normalization + of README. Explicit LF Markdown convention and normalization restored + git diff --check to exit 0. This changed no functional source. The user's + core.autocrlf=true still emits a non-blocking README LF-to-CRLF notice; no Git + configuration was changed. Build warnings/errors remain 0/0. +4. Final ignore assertions used git check-ignore --no-index --quiet, avoiding + verbose output's matched-negation ambiguity. Confirmed .env/.env.local, + local private data, bin/obj and TestResults are ignored; .env.example, + synthetic fixture paths and both assignment/report paths remain visible. + +Final Git status/diff/inventory and protected-file/index checks were reviewed. +No accidental extra files, secret assets, staged files or scope drift were found. +Generated output stays under ignored src project bin/obj directories. + +Hardware, UI/MAUI, simulation, AI and non-Windows runtime checks were NOT EXECUTED +because they are outside Step-01, not skipped requirements or success claims. + +## 17. Deviations and rationale + +- User supplied "promps/Step-01.md"; that path does not exist. Executed the actual + repository assignment at prompts/Step-01.md after recursively reading all + repository content outside Git metadata. No replacement assignment was created. +- Added repository-local NuGet.Config, a permitted root config, to remove + inherited-feed ambiguity exposed by actual restore. No architecture change. +- Identifier padding rejection and repeated DI setup rejection are documented, + tested local invariant choices, not target inference or fallback. +- No required scope, target framework, UI architecture or handoff was substituted. + No other agent was invoked. + +## 18. Recommendations and stop + +Orchestrator should compare the implementation and test coverage with the +original assignment, inspect the unchanged protected files and actual reference +graph, and review the recorded restore correction, package support choice and +54 passing cases. Worker completion does not update orchestration state. + +If accepted, the orchestrator may prepare a separate Step-02 assignment for +manual handoff. This worker has not created it, modified roadmap/state, committed, +pushed or begun any later feature. + +Worker stops after persisting this report. +``` diff --git a/prompts/Step-01A-Report.md b/prompts/Step-01A-Report.md new file mode 100644 index 0000000..5fdb18c --- /dev/null +++ b/prompts/Step-01A-Report.md @@ -0,0 +1,204 @@ +``` +# Step-01A Worker Report + +## Status + +**COMPLETE** — implementation, full solution/native builds, regression tests and +Windows native smoke verification are complete. Manual orchestrator acceptance +remains pending. Step-02 was not started. + +## Implemented functionality + +- Added one Windows-first .NET 10 MAUI Blazor Hybrid executable, `AutoForge.Client`, + hosting the entire routed application through `BlazorWebView`. +- Added `AutoForge.UI` and `AutoForge.Components` .NET 10 Razor Component + Libraries. UI owns the home, target-selection and not-found routes, layout and + navigation. Components owns the accessible, text-safe, reusable `StatusNotice`. +- Moved the existing Application target-selection implementation under + `Features/ExecutionTargets/SelectExecutionTarget` without changing its public + namespace, explicit-kind validation, typed failures, registration snapshot or + no-fallback behavior. +- Composed the existing application registration in Client with an intentionally + empty production metadata registry. The UI displays `ProviderNotRegistered`; + it does not fabricate a provider or claim connection, capability or + authorization. +- Added headless rendered component/UI tests and actual project-graph assertions. + The original 35 unit and 19 integration tests remain; the expanded suites have + 39 unit and 26 integration tests (65 total). +- No vehicle feature, hardware operation, simulation/diagnostics engine, backend, + database, cloud service, browser/server host or additional application + executable was introduced. + +## Projects, files and architectural changes + +The solution now has seven projects: Core, Application, Components, UI, Client, +UnitTests and IntegrationTests. The actual production references are: + +- Client -> UI and Application. +- UI -> Components and Application. +- Application -> Core. +- Components -> no AutoForge project. +- Core -> no AutoForge project. +- Tests -> portable production projects as needed; neither test project references + or launches Client. + +Client is the only application executable. Application target selection is +feature-organized at +`src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/`. +Routes and feature presentation are in UI; the reusable status control is in +Components. The UI calls the real resolver through DI. The design adds no +mediator, generic repository/manager layer, empty future feature slice or +speculative service. + +Added the three projects and Windows platform bootstrap under `src`; updated +`src/AutoForge.slnx`; added UI routes, pages, view model, layout and RCL styles; +added the Components status control and its styles; and added component, +UI/application and project-graph test coverage to the existing test projects. +The host page now explicitly loads `_content/AutoForge.UI/app.css`, in addition +to the generated scoped-style bundle. Application source files were moved into +the feature slice while preserving their namespace and behavior. + +Removed unused template sample pages/components/JavaScript and non-Windows +platform scaffolding. Kept the legitimate MAUI/Windows startup, manifest, +resources and Windows platform entry point. No useful Step-01 application +behavior or tests were removed. + +Updated the root README, `docs/README.md`, `docs/architecture.md` and +`docs/build-and-test.md`. Updated ADR-0001 to retain its historical foundation +decisions and explicitly supersede only its dual-shell/deferred-host decision. +Added `docs/adr-0002-single-shell-vsa.md` for the corrected single-shell/RCL/VSA +decision. + +## Tests and verification + +Environment inspection: + +- Windows `10.0.26200.0`; .NET SDK `10.0.402`; .NET and ASP.NET Core runtime + `10.0.13`. +- Windows SDK target `10.0.26100.0`; `maui-windows` workload manifest `10.0.110` + (`10.0.110/10.0.100` as listed); WebView2 Runtime `155.0.4283.62`. +- After the workload-restore incident below, `dotnet workload list` reported + workload version `10.0.403`; installed Android/iOS/MacCatalyst workloads were + not used as Client targets. +- Central package versions include MAUI Controls and BlazorWebView.Maui + `10.0.110`, Components.Web `10.0.13`, DI abstractions `10.0.14`, Test SDK + `18.11.0`, xUnit `2.9.3` and Visual Studio xUnit runner `4.0.1`. Tests use the + existing VSTest/xUnit runner. + +Successful restore/build commands: + +- `dotnet restore .\src\AutoForge.Client\AutoForge.Client.csproj --runtime win-x64` + — exit 0; restored the Windows runtime pack. +- `dotnet restore .\src\AutoForge.slnx` — exit 0; all projects up to date. +- `dotnet build .\src\AutoForge.slnx --configuration Release --no-restore` — + exit 0; all seven projects built, 0 warnings, 0 errors. +- `dotnet build .\src\AutoForge.Client\AutoForge.Client.csproj --configuration Release --framework net10.0-windows10.0.26100.0 --no-restore` + — exit 0; actual `net10.0-windows10.0.26100.0` / `win-x64` native target, + 0 warnings, 0 errors. + +Successful test commands and results: + +- `dotnet test .\src\tests\AutoForge.UnitTests\AutoForge.UnitTests.csproj --configuration Release --no-build` + — 39 passed, 0 failed, 0 skipped. +- `dotnet test .\src\tests\AutoForge.IntegrationTests\AutoForge.IntegrationTests.csproj --configuration Release --no-build` + — 26 passed, 0 failed, 0 skipped. +- `dotnet test .\src\AutoForge.slnx --configuration Release --no-build` + — full solution regression command; both test projects ran, 65 passed, 0 failed, + 0 skipped. + +Unit coverage includes descriptor/resolver regressions and actual rendered status +component tones and safe text encoding. Integration coverage renders the real +UI routes with the real Application resolver, including registered synthetic +metadata, empty/unknown providers, invalid inputs, kind mismatch and unknown +routes. Project graph tests inspect actual project references. These headless +tests do not substitute for the following native smoke checks. + +## Native Windows smoke evidence + +Launched the built native Client executable from +`src\AutoForge.Client\bin\Release\net10.0-windows10.0.26100.0\win-x64\AutoForge.Client.exe` +with an isolated WebView2 profile and temporary local DevTools port. The native +window title was `AutoForge`; WebView2 exposed the app page at `https://0.0.0.1/`. +Observed: + +- The home route rendered the foundation content and navigation. The unhandled + error banner was hidden (`display: none`). +- Navigation to `/execution-targets` rendered the explicit empty-provider notice, + input fields and all three target kinds. +- Submitting provider identifier `native-smoke-unregistered` with + `PhysicalHardware` rendered “Provider ... is not registered” with error tone. + No connection or operation was performed. +- An unmatched `/native-smoke-unknown` path rendered the explicit “Page not found” + presentation and navigation. +- Host `app.css` returned HTTP 200. The generated `AutoForge.UI` and + `AutoForge.Components` scoped CSS assets both returned HTTP 200 and contained + their expected UI/status-notice styles. +- No unhandled error banner appeared during navigation or form submission. + +The initial native inspection found that the host HTML did not link the UI RCL's +global `app.css`, which left the template error element visible despite healthy +startup. Added the explicit RCL static-asset link, rebuilt and repeated the +native checks above successfully. The native process was stopped and both exact +temporary WebView2 smoke profiles were removed. + +## Acceptance criteria evidence + +| Criterion | Status | Evidence | +|---|---|---| +| AC-01 | PASSED | Existing Core/Application behavior, public namespace and all 54 accepted Step-01 test cases retained; expanded suites pass 65 tests. | +| AC-02 | PASSED | Seven-project solution; only application executable is Windows-first MAUI Blazor Hybrid Client; native Windows TFM build succeeds. | +| AC-03 | PASSED | BlazorWebView root is UI `Routes`; pages/layout/navigation are in UI, generic status component in Components; native home, selection and not-found routes verified. | +| AC-04 | PASSED | `ProjectGraphTests` and actual project manifests verify allowed references, no forbidden reverse edges/cycles, no extra application host. | +| AC-05 | PASSED | Target resolver moved into feature slice; public namespace, typed failures, validation, exact selection and no-fallback regressions pass. | +| AC-06 | PASSED | 39 headless unit tests and 26 integration tests render real components/routes and exercise actual Application DI; no Client reference required. | +| AC-07 | PASSED | Full Release solution build and direct Windows Client build: 0 warnings/errors; both test projects and full-solution test command pass. | +| AC-08 | PASSED | Native app loads both RCL style assets and routes; empty-provider notice and explicit unregistered selection observed without backend/model/vehicle. | +| AC-09 | PASSED | README, documentation index, architecture, build/test guide, ADR-0001 supersession and ADR-0002 match actual architecture and limitations. | +| AC-10 | PASSED | This report created; protected assignments/orchestration files preserved; no Step-02, stage, commit or push. | + +## Failures, deviations and environment side effect + +- The first Windows solution build needed the runtime-specific `win-x64` restore + to obtain its MAUI runtime pack (`NETSDK1112`); the explicit restore above + resolved it. +- An initial integration restore identified a redundant explicit + `Microsoft.Extensions.DependencyInjection` package (`NU1510`) because the + project already uses the ASP.NET Core framework reference. The redundant direct + package was removed from the integration-test project; restore and tests then + succeeded. No test assertion was removed. +- Native smoke identified and fixed the missing global UI stylesheet link as + described above. All final checks were rerun after the fix. +- **Unintended environment-level workload action:** during prerequisite + inspection, `dotnet workload restore .\src\AutoForge.slnx --skip-manifest-update` + was mistakenly invoked. It began updating workload manifests and was stopped. + Subsequent `dotnet workload list` output reports workload version `10.0.403` + and newer iOS/MacCatalyst manifest versions; the required `maui-windows` + manifest remains `10.0.110`. No rollback was attempted. This changed the local + tool environment, not repository source/configuration. +- A first DevTools form probe dispatched only an `input` event and therefore did + not trigger Blazor's `change` binding. The smoke probe was corrected to dispatch + the bound change event; explicit submission then produced the expected + `ProviderNotRegistered` result. No product-code change was needed for that + harness correction. +- No required build, test or native check remains blocked or unexecuted. + +## Documentation, preservation and handoff + +ADR-0002 records one native shell, two purposeful RCLs and feature-oriented +application slices. ADR-0001 retains the valid platform-neutral foundation, +explicit-target and no-fallback decisions; only the former dual-shell and +deferred-host decision is superseded. README/docs distinguish implemented +metadata selection from planned vehicle, simulation, diagnostics, AI and +hardware capabilities. + +The worktree was already dirty with accepted Step-01 implementation and +orchestration files. Those changes were preserved; no destructive Git operation, +staging, commit or push was performed. `prompts/ROADMAP.md`, `prompts/STATE.md`, +the Step-01 assignment/report, Step-01A assignment, Step-02 assignment and +instruction files were not edited by this correction. No unrelated dirty files +were reverted. + +Implementation and verification are complete for orchestrator review. The +orchestrator must perform manual acceptance; Step-02 remains held and was not +executed. +``` diff --git a/prompts/Step-01A.md b/prompts/Step-01A.md new file mode 100644 index 0000000..8adfb15 --- /dev/null +++ b/prompts/Step-01A.md @@ -0,0 +1,399 @@ +# Step-01A - Single-shell MAUI/RCL and vertical-slice foundation + +## STEP IDENTIFIER + +Step-01A, an owner-directed architectural correction to accepted Step-01. +This is the sole active assignment. Step-02 is unexecuted and NOT authorized. + +## STEP TITLE + +Preserve the accepted foundation while establishing one thin MAUI Blazor Hybrid +Client, two purposeful Razor Component Libraries, and feature-oriented application +organization. + +## OBJECTIVE + +Deliver a minimal but working Windows-first .NET 10 application foundation: + +`AutoForge.Client -> AutoForge.UI -> AutoForge.Components` + +Client hosts the complete application UI through BlazorWebView and composes +application services in-process. Application use cases follow Vertical Slice +Architecture within a modular monolith. Preserve domain behavior, useful source, +configuration and all accepted regression coverage. + +Implement only this correction, build/test the actual targets, record evidence in +`prompts/Step-01A-Report.md`, and STOP. Do not begin Step-02. + +## ARCHITECTURAL CONTEXT AND AUTHORITY + +The owner's 2026-10-28 architectural realignment supersedes previous dual-shell +requirements and the plan to defer all host/RCL work until Step-05. + +- Sole initial application executable: **AutoForge.Client**, a .NET 10 MAUI Blazor + Hybrid application, initially Windows. +- **AutoForge.UI**: .NET 10 RCL containing the complete application UI, including + routing, pages, navigation, layouts, feature presentation and interaction flows. +- **AutoForge.Components**: .NET 10 RCL for generic reusable components/controls. +- Client is thin: native startup/configuration, lifecycle, BlazorWebView, + dependency injection and platform services. No feature implementations inside it. +- No standalone Blazor WebAssembly shell, separate AutoForge.Web/AutoForge.Maui + hosts, Blazor Server substitute or initial backend executable is required. +- Application, simulation, diagnostics, calibration and AI services can execute + in-process. Additional hosts/processes need a concrete requirement and approval. +- Application features use cohesive vertical slices, not generic technical layers, + artificial manager/repository abstractions or mandatory mediator boilerplate. +- Reusable engines/protocols/domain capabilities remain independent of UI and + their coordinating application slices; do not force every library to reference + Application or create every planned subsystem now. + +Read [ROADMAP.md](ROADMAP.md), [STATE.md](STATE.md), the original +[Step-01](Step-01.md) and [report](Step-01-Report.md), and current technical docs. +Old host descriptions in those historical files are superseded by this correction. +Do not alter historical assignments/reports or execute the held [Step-02](Step-02.md). + +## CURRENT IMPLEMENTATION STATE + +Actual inspection found only these projects in [AutoForge.slnx](../src/AutoForge.slnx): + +| Project | Current responsibility / references | +|---|---| +| `src/AutoForge.Core` | net10.0 immutable execution-target kind/descriptor; no project or package dependencies | +| `src/AutoForge.Application` | net10.0 target resolution, typed failures and eager DI registration; references Core and DI abstractions | +| `src/tests/AutoForge.UnitTests` | net10.0 real Core/Application invariants; references Core/Application | +| `src/tests/AutoForge.IntegrationTests` | net10.0 real target-selection DI/container composition; references Core/Application | + +No Client, UI, Components, Web or Maui project exists. There are no current Razor +pages/components to relocate or old hosts to delete. Do not invent migration work +or recreate the accepted libraries. + +Existing Application code is under `ExecutionTargets`. The Core descriptor is +sealed and validated; the resolver snapshots registrations, uses ordinal +case-insensitive IDs and rejects missing/unknown/duplicate/mismatched selections. +The DI extension validates eagerly and rejects repeated registration. +Production contains no connected/available provider implementation. + +The accepted worker report records SDK 10.0.402, runtime 10.0.13 on Windows x64, +successful Release build with zero warnings/errors and 54 passing cases: +35 unit, 19 integration, zero failed/skipped. These are previous worker results, +not new correction verification or orchestrator runtime execution. + +Existing configuration includes a stable same-feature-band SDK pin, nullable +references, warnings as errors, central package versions and repository-local +nuget.org feed. Preserve these conventions and the working VSTest/xUnit stack. +MAUI/Windows/WebView2 prerequisites have NOT been verified. + +The worktree contains accepted unstaged/uncommitted implementation. Preserve it, +any concurrent changes, Git metadata and the three top-level project directories +`docs`, `src`, `prompts`. No root tests/artifacts or nested repository. + +## REQUIRED IMPLEMENTATION + +### 1. Inspect prerequisites and scope before editing + +- Inspect Git status, instructions, solution, source/tests, configuration and docs. + Reconcile differences from this snapshot without discarding unrelated work. +- Inspect installed .NET SDK, MAUI workloads/templates, supported Windows target + framework/Windows SDK and desktop/WebView2 prerequisites. Record actual versions + and exact commands. Do not infer native readiness from the accepted headless build. +- Use compatible .NET 10 templates/project tooling where available. Verify actual + package/API/template capabilities before adding references or code. +- Do not install major SDKs/workloads/Windows components/drivers without + authorization. If missing, report precise prerequisites and native checks as + BLOCKED/NOT EXECUTED, not PASSED. Preserve the architecture; do not substitute a + browser/server host or quietly exclude Client from the required solution. +- Continue independent RCL/application/test work where feasible, but do not claim + overall completion if mandatory native build/startup evidence remains blocked. + +### 2. Add the three UI projects to the existing solution + +| Project | Required foundation | +|---|---| +| `src/AutoForge.Client/AutoForge.Client.csproj` | .NET 10 MAUI Blazor Hybrid executable; initially Windows only, using an actual supported Windows TFM and verified MAUI tooling | +| `src/AutoForge.UI/AutoForge.UI.csproj` | net10.0 Razor Component Library for the entire routed application UI | +| `src/AutoForge.Components/AutoForge.Components.csproj` | net10.0 Razor Component Library for reusable vehicle-independent UI | + +Expected solution total: seven projects, preserving the existing four. Do not +scaffold Android/iOS/Mac targets merely because a template includes them; additional +platforms require a later need and verification. + +Use the framework's actual BlazorWebView bootstrap, root selector/component, +host page, resources, CSS and RCL static asset conventions. Client may contain +necessary MAUI App/MainPage/platform bootstrap and the host HTML, but application +Router, routes, layouts, navigation and feature pages must be in UI. +Ensure assets resolve from both RCLs and the root component loads the UI assembly. +Do not leave a Router pointed at an empty Client assembly. + +Remove unused template Counter/Weather/sample services or relocate only genuinely +useful content. Do not create a second executable, separate backend, startup HTTP +server, browser host or fake platform fallback. Test runner executables are not +application shells. + +### 3. Establish meaningful minimal RCL behavior + +Provide only a small foundation UI, not future automotive features: + +1. A foundation/home page and a minimal execution-target metadata selection page + in UI, with working navigation/layout and explicit unknown-route handling. +2. A generic reusable status/notification component in Components, used by the UI. + Give it a small useful parameter/state contract and test its actual rendered + behavior. Do not add placeholder gauges/charts that have no real data source. +3. The selection page invokes the existing application use case through DI, + requiring explicit provider identifier and target kind. Production registry + remains empty; display an honest unavailable/not-registered outcome. +4. Keep invalid-input/application errors visible to the user with specific handling, + not a broad catch, blank page, success-shaped fallback or hidden failure. +5. A selected metadata descriptor, if supplied in a synthetic headless test, must + never be labeled connected, hardware-capable, write-approved or programmable. +6. Keep application validation in the application/domain boundary. Razor code + contains presentation/input handling, not a duplicate resolver/business workflow. + +The application must start without a vehicle, AI model, cloud account, backend or +native automotive driver. No synthetic production provider is to be registered +just to make the screen look connected. + +### 4. Establish the vertical-slice foundation without rewriting behavior + +Retain AutoForge.Application immediately: a real use case already exists there. +Organize the existing target-selection operation as a cohesive feature slice, +for example `Features/ExecutionTargets/SelectExecutionTarget`. +Keep its service/contract, errors and composition close to the use case as useful. + +- Preserve validation, errors, exact descriptor identity, comparison semantics, + mutation isolation, duplicate handling, empty-registry behavior and no fallback. +- Moving files is sufficient if it establishes feature ownership; do not wrap + every method in requests/handlers or duplicate the resolver behind a new layer. +- Preserve public contracts/namespaces where practical. If a necessary rename + changes references, update all consumers/tests/docs coherently and explain it; + no speculative compatibility adapter is required. +- Keep target kinds/descriptors in reusable Core rather than dragging domain + contracts into UI, Client or an application-only request type. +- UI may use a `Features/Foundation` or `Features/ExecutionTargets` arrangement + for the two real presentation operations. Do not create empty Vehicles, + Diagnostics, Simulation, Calibration, Telemetry or AI feature directories. +- Document how future slices coordinate independently testable capabilities. + Do not implement those capabilities now. +- Do not add MediatR, generic repositories/managers, service locators, automatic + discovery or new infrastructure solely to demonstrate architecture. + +### 5. Enforce project and composition boundaries + +Required references: + +- Client -> UI; Client -> Application as needed for composition. +- UI -> Components; UI -> Application/contracts and domain types as needed. +- Application -> Core, retaining its narrow infrastructure dependencies. +- Components -> no other AutoForge production project in this foundation. + +Forbidden directions include Components -> UI/Client/Application, UI -> Client, +Core/Application -> UI/Client/Components, and production -> tests. No cycles. +Do not introduce a requirement for every capability library to depend on +Application. Future native adapters are composed by Client behind suitable ports. + +Headless tests must exercise Components/UI/application features without referencing +or starting Client. The native shell must use the same application registration +and services tested headlessly, not a second fake implementation. + +Review central package pins, RCL/MAUI references and shared build settings for +actual .NET 10 compatibility. Add only justified dependencies. Do not force +desktop-only settings or native targets onto Core/RCL/test projects, add a +server-only shared-framework requirement to MAUI by accident, suppress warnings +globally, or change SDK/test tooling just to conceal an integration failure. + +## FILES OR PROJECTS EXPECTED TO CHANGE + +- Add Client, UI and Components under `src`; update the existing solution. +- Move/reorganize the existing Application feature and update references only + where required, preserving Core and existing behavior. +- Extend the existing UnitTests/IntegrationTests with meaningful component, + application-UI integration and dependency-boundary coverage. Reference RCLs in + tests only as required; no new test project is expected. +- Update central package/build configuration only where justified by MAUI/RCL work. +- Update root README, documentation index, architecture and build/test guide. +- Add a superseding architecture ADR under `docs`, and mark affected old decisions + superseded while retaining their historical context. +- Under `prompts`, create/update only `Step-01A-Report.md`. + +Do not change any assignment, ROADMAP, STATE, Step-01 report or held Step-02. +Do not modify/create `.github/copilot-instructions.md` or override instruction files. +Do not stage, commit, push, initialize Git, reset the repository or remove reports. +If an unexpected obsolete host appears due to concurrent work, inspect and preserve +its useful content before a narrowly justified migration; do not delete broad trees. + +## INTERFACE AND DEPENDENCY REQUIREMENTS + +The primary direction remains Client -> UI -> Components; UI invokes application +feature contracts, Client composes them in-process, and Core stays independent. +RCL/application testing is independent of MAUI. A backend is not required for +separation of concerns. + +Use normal DI and small direct services/handlers. No UI or application feature may +acquire arbitrary hardware write authority. Preserve the distinction between +simulation, replay and physical target metadata. No operation execution is added. +Future deterministic simulation remains AI-independent with an isolated oracle. +Existing local-first behavior and all hardware safety/prohibited-operation +restrictions remain in force. + +## TESTING REQUIREMENTS + +### Unit and regression tests + +Preserve all 35 existing unit and 19 integration cases/invariants. Add substantive +tests for any changed/new feature behavior and reusable component rendering. +If moving names/files, map the original cases to their preserved equivalents. +Do not delete assertions or introduce required skipped tests to report a green run. + +For the generic component, verify meaningful rendered state/content changes and +safe text rendering, not merely that the type exists or DI can construct it. +Use framework-supported headless rendering or a narrowly justified compatible +test tool; verify its actual API rather than adding packages speculatively. + +### Integration and architecture tests + +Exercise the actual UI/Application/Components implementation without Client: + +1. Render the foundation UI and verify it uses the reusable component and actual + application service contract through DI. +2. Exercise metadata selection with explicit synthetic registrations in tests: + exact selection, empty registry, invalid input and mismatched kind remain + truthful and visible; no connection/write-approval claim or fallback. +3. Verify application route ownership/navigation and unknown-route behavior in + the UI assembly, with native route smoke evidence below. Do not count only + string searches or file-existence assertions as UI integration. +4. Verify the actual project graph has Client -> UI -> Components, no reverse/ + forbidden references or cycles, one intended production executable, and no + required obsolete WebAssembly/web/backend host. +5. Verify the feature registration used by Client is the real tested registration; + preserve eager validation, immutable snapshots and explicit target selection. + +Graph/source-policy assertions supplement, not replace, actual Razor compilation, +rendered-behavior integration, native build and native startup evidence. +Do not mock the feature/component under test or relabel metadata tests as hardware +or native application integration. + +### Required build and test execution + +Record actual SDK/workload/Windows SDK/WebView2 versions and exact commands. +Build Core, Application, both RCLs and tests with the existing Release conventions. +Build the native Client for its actual Windows TFM, then the applicable complete +solution targets when prerequisites permit. + +Use repository-root PowerShell entry points, verified for the actual project +configuration: + +- Restore affected projects/solution after necessary manifest changes. +- `dotnet build .\src\AutoForge.slnx --configuration Release --no-restore` + when the single Windows Client target and installed workloads permit. +- Build Client directly with its actual Windows TFM if needed to identify the + native failure precisely. Do not apply a Windows `--framework` override to all + portable projects in the solution. +- Run both existing test projects explicitly in Release using the existing + VSTest runner; also run any appropriate full-solution regression command that + actually supports the configured native target. + +If native workloads are missing, build/test independent projects directly and +report those successful results separately. Do not use a partial solution filter +or an excluded Client to claim the complete solution passed. Do not claim a MAUI +build from successful Core/RCL/test compilation alone. + +### Native startup smoke verification + +Where desktop execution is available, launch the actual Client, verify that +BlazorWebView displays the UI RCL, both foundation routes/navigation and shared +component assets work, and the empty-provider outcome is visible without a backend, +vehicle, driver or model. Record launch method, observed UI behavior, errors and +supporting evidence. A running process or a screenshot of a native blank window +does not prove the RCL loaded. + +If startup is impossible due to the desktop session, WebView2 or another exact +prerequisite, mark native smoke BLOCKED/NOT EXECUTED and describe the limitation +separately from compile/headless tests. Do not mark COMPLETE while required native +build or smoke evidence remains missing; report BLOCKED/INCOMPLETE for review. +Only the orchestrator can accept the step and unblock subsequent work. + +## DOCUMENTATION REQUIREMENTS + +Update the root README and technical documents to describe actual results: + +- One Client executable, UI RCL, Components RCL, in-process modular monolith and + primary dependency graph, with a Mermaid diagram where useful. +- Exactly which routes/pages/components and application slice exist, and their + metadata-only limitations; no simulation/diagnostics/AI feature claims. +- Feature ownership and future slice organization without mandatory mediator, + generic technical-layer boilerplate or speculative projects. +- Current SDK/workload/Windows/WebView2 prerequisites, native startup method, + portable versus native build/test commands and honest platform limitations. +- Implemented, in-progress and planned scope, Step-01 historical acceptance and + Step-01A worker completion versus pending orchestrator acceptance. + +Create a focused ADR recording the owner's corrected single-shell/RCL/VSA +decision. Supersede the old dual-shell/deferred-host portions of ADR-0001 without +erasing the valid foundation decisions or falsifying its history. Remove obsolete +host requirements from active README/architecture/build descriptions. Historical +reports/assignments remain unchanged and explicitly historical, not active design. +Update `docs/README.md` to link actual documents; no empty placeholder documents. + +## ACCEPTANCE CRITERIA + +| ID | Criterion | Required evidence | +|---|---|---| +| AC-01 | Accepted Core/Application behavior, useful code/configuration, all 54 prior cases and history preserved; exact repository layout/manual workflow maintained | Git review, case mapping and regression outcomes | +| AC-02 | Existing solution includes the four original projects plus Client/UI/Components; Client is the only initial application executable and a genuine .NET 10 MAUI Blazor Hybrid target | Solution/project graph, actual native configuration/build evidence | +| AC-03 | Client hosts UI via BlazorWebView; application routes/pages/layout/navigation reside in UI, generic component in Components; no shell feature implementations | Source paths, Razor compilation, rendered tests and native smoke evidence | +| AC-04 | Required Client -> UI -> Components references and allowed application composition exist, without reverse/forbidden references or cycles | Architecture assertions and inspected actual project graph | +| AC-05 | Existing Application is retained and target selection is feature-organized with unchanged explicit/no-fallback validation and errors; no unnecessary mediator/layers/future slices | Feature/source paths, regression tests and design explanation | +| AC-06 | Real headless component and UI/application integration tests verify rendered behavior and errors independently of MAUI | Actual tests, assertions, commands and nonzero discovered/passed counts | +| AC-07 | Affected projects, RCLs, native Windows Client and applicable complete solution targets build; both test suites/regressions pass | Exact commands, targets, versions, exit outcomes, warnings and per-project counts | +| AC-08 | Native Client loads UI/navigation/shared assets and honest empty-provider behavior without a backend/model/vehicle | Native launch observations/evidence; exact blocker if execution unavailable, never a false pass | +| AC-09 | README, technical docs/index and superseding ADR match one shell, two RCLs, VSA/modular monolith and actual verification limits | Documentation paths and supersession/status summary | +| AC-10 | Correct report produced; assignments/state/roadmap/protected instructions and old reports preserved; worker stops without Step-02 execution | `prompts/Step-01A-Report.md`, preservation/scope review and explicit stop | + +Map every criterion to PASSED, FAILED, NOT EXECUTED or BLOCKED with concrete +evidence. COMPLETE requires all required verification, including native evidence. +Missing workload/runtime prerequisites are real blockers, not permission to +replace architecture, suppress failures or start Step-02. + +## OUT-OF-SCOPE WORK + +Vehicle/profile implementation, module discovery/diagnostic protocols, simulation/ +physics, telemetry acquisition/recording/replay, calibration editing/programming/ +backups, AI inference/knowledge/research, driver integration, actual hardware +operations, future application features, additional executable hosts/backends, +new platforms, databases, containers, cloud services and automatic agent handoffs. + +Do not implement every example slice/library/component listed in the product +vision. No emissions defeat, anti-theft bypass, mileage falsification or safety +disabling functionality is permitted. + +## REPORTING REQUIREMENTS + +Create `prompts/Step-01A-Report.md` entirely inside exactly one plain triple-backtick +code fence, without a language tag or content outside it. Use no nested fences. +Use the same copy-window format for the final chat report. + +Include: + +1. Step identifier/title and COMPLETE, INCOMPLETE or BLOCKED status. +2. Implemented functionality summary, distinct from future capabilities. +3. Files/projects created and modified; moves/removals with preservation rationale. +4. Actual project/reference graph, sole executable, application feature arrangement, + UI/component ownership, and architectural changes. +5. Unit tests created/modified and original-case preservation. +6. Integration/architecture tests created/modified and actual rendered/application + boundaries tested, distinct from native smoke. +7. SDK, workload, Windows SDK, WebView2, package and runner inspection/results. +8. Exact build/restore commands, targets, exit outcomes, warnings/errors and any + partial versus full-solution results. +9. Exact test commands/results and per-project discovered/passed/failed/skipped counts. +10. Native launch method, observed UI/navigation/assets/error behavior and evidence, + or exact missing prerequisites and unexecuted checks. +11. AC-01 through AC-10 evidence table. +12. Documentation changes, README changes and ADR supersession. +13. Known limitations, outstanding issues/blockers, corrected failures and any + failed/unexecuted verification. +14. Deviations and rationale; relevant recommendations for orchestrator review. +15. Protected assignment/report/orchestration preservation and final Git review. + +Do not claim headless tests prove native integration or metadata proves operational +capability. Save the report and STOP. Do not modify orchestration files, regenerate +Step-02, begin profile work, invoke another agent, stage, commit or push. diff --git a/prompts/Step-02.md b/prompts/Step-02.md new file mode 100644 index 0000000..85ff495 --- /dev/null +++ b/prompts/Step-02.md @@ -0,0 +1,493 @@ +# Step-02 - Vehicle profiles and control module model + +## STEP IDENTIFIER + +Step-02, regenerated 2026-10-28 following acceptance of Step-01A. +This assignment explicitly **supersedes the previously prepared but unexecuted +Step-02 assignment** following the Step-01A architectural correction. The old +headless/four-project/dual-host instructions no longer apply. +This is the only currently authorized implementation assignment. + +## STEP TITLE + +Introduce validated vehicle profiles, extensible module metadata, provenance, +versioned JSON interchange and explicit configuration selection through cohesive +application feature slices, with a thin consumer in the existing UI. + +## OBJECTIVE + +Deliver a cohesive vertical slice that imports a clearly synthetic vehicle +profile, validates its module identities/capabilities and provenance, registers +multiple saved configurations, selects an exact configuration, and exports it +without losing information. Demonstrate the full path through real application +features, DI-based integration tests and a minimal profile metadata page in the +existing MAUI-hosted UI. + +Do not implement simulation, diagnostic communication, calibration editing, +programming or AI. Profile metadata is not evidence that an operation exists +or is authorized. + +You are the WORKER. Execute only this assignment, write +`prompts/Step-02-Report.md`, and STOP for manual orchestrator review. + +## ARCHITECTURAL CONTEXT + +Read [ROADMAP.md](ROADMAP.md), [STATE.md](STATE.md), and the existing +[architecture](../docs/architecture.md) and +[build/test policy](../docs/build-and-test.md). + +AutoForge is one local-first .NET 10 platform integrating deterministic simulation, +vehicle-wide diagnostics/telemetry/calibration, and replaceable local AI. Vehicle +and module definitions must be data-driven rather than fixed to a manufacturer, +engine ECU, transmission controller or fixed list of module roles. + +Core owns platform-neutral domain types and invariants. Application uses Vertical +Slice Architecture within a modular monolith; profile import/export/list/select +are cohesive feature operations, not a generic service/repository layer. +Organize them under `Features/Vehicles` or an equally clear profile feature area. +Share feature-local schema/catalog code only where it is genuinely reused; do not +force every operation into requests/handlers or introduce a mediator. + +The sole executable remains AutoForge.Client (.NET 10 MAUI Blazor Hybrid); +AutoForge.UI owns pages/routes/feature presentation and AutoForge.Components owns +generic controls. UI invokes application contracts; Client performs thin in-process +composition. Preserve Client -> UI -> Components and inward domain dependencies. +Keep all seven projects. No new shell/RCL/backend or restructuring belongs here. + +All source and automated tests remain under `src`; tests under `src/tests`. +Only `docs`, `src`, and `prompts` are top-level project directories. Preserve root +configuration and protected infrastructure. Handoffs are manual, with no watchers, +polling, automatic agent invocation or next-step execution. + +## CURRENT IMPLEMENTATION STATE + +Accepted Step-01 plus Step-01A provide: + +- [AutoForge.slnx](../src/AutoForge.slnx) with Core, Application, Components, UI, + Client, UnitTests and IntegrationTests. Client targets + `net10.0-windows10.0.26100.0`/win-x64; the other projects target `net10.0`. +- Client -> UI/Application; UI -> Components/Application; Application -> Core. + Neither portable test project references Client; Components has no AutoForge + project dependency and there is no cycle or separate backend. +- Immutable target descriptors for Simulation, RecordedReplay and PhysicalHardware. + Resolution requires an explicit provider identifier and kind; unknown, + mismatched, invalid or ambiguous inputs fail without fallback. +- Snapshot isolation and eager DI validation through + [AddAutoForgeTargetSelection](../src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ServiceCollectionExtensions.cs). + There are no production provider registrations or operational transports. +- Existing application target-selection slice at + `Features/ExecutionTargets/SelectExecutionTarget` with stable public namespace. + Existing UI routes `/`, `/execution-targets` and explicit not-found presentation, + a feature-local selection view model, `AddAutoForgeUi`, and reusable StatusNotice. + Client uses real application DI with an empty provider registry. +- SDK 10.0.402 with stable same-feature-band patch roll-forward, shared nullable/ + warnings-as-errors conventions, central package pins and a working VSTest/xUnit + test stack. +- Worker-recorded successful full solution/direct native Release builds, zero + warnings/errors, 39 unit plus 26 integration cases passed and zero failed/skipped. + This includes all 54 Step-01 regressions. Native Windows route/asset/selection + smoke was reported. See [Step-01A report](Step-01A-Report.md). +- Reported native prerequisites: MAUI Windows manifest 10.0.110, Windows SDK + 10.0.26100.0, runtime 10.0.13 and WebView2 155.0.4283.62. +- No vehicle/profile model, simulator, diagnostic/telemetry engine, persistent + storage, AI or hardware operation exists. + +The orchestrator accepted Step-01A by inspecting implementation and evidence, +not by rerunning builds/tests. Reinspect Git status and applicable instructions; +existing implementation changes are still unstaged/uncommitted and must not be +discarded. Preserve all prior assignments/reports. + +Known hygiene/process notes: + +- The prior worker mistakenly invoked workload restore during inspection and + reported manifest updates. No rollback occurred. Do not run `dotnet workload + restore`, install, update, repair or uninstall as inspection or without separate + authorization. Read-only SDK/workload listing is sufficient unless a concrete + failure identifies a prerequisite. Ordinary package restore is different. +- Raw Git whitespace checking flags README CRLF against a mixed-line-ending index; + no trailing spaces/tabs were found. Normalize README to the repository's existing + Markdown LF convention during its required update, without changing Git settings. + +## REQUIRED IMPLEMENTATION + +### 1. Vehicle definitions and saved profiles + +Introduce a small, strongly typed domain model sufficient to represent: + +1. A stable profile identifier, profile/configuration revision and vehicle identity + or definition reference. Keep schema version separate from profile revision. +2. Manufacturer/model/model year and optional trim, engine, transmission and + drivetrain information. Unknown optional facts must remain explicitly unknown, + not fabricated defaults such as a zero model year or invented engine. +3. A saved vehicle configuration with an arbitrary inventory of module instances. + The same vehicle may have multiple saved configurations or revisions; different + vehicles may have different inventories. +4. Module-instance identity distinct from its human-readable role/name, plus + hardware, software, firmware and calibration identifiers where known. + Unknown identifiers do not become "compatible" or a complete firmware image. +5. Calibration identity/reference metadata only, sufficient to distinguish saved + configurations. Do not model memory offsets, tune tables, firmware bytes or + real manufacturer definitions in this step. + +Use explicit validation for required fields, positive revision/schema values, +identifier uniqueness and valid optional values. Define identifier comparison +semantics; do not silently trim or merge ambiguous identities. Modules of the same +role may coexist if their instance identities differ. Do not use a fixed enum of +module types that prevents a new/custom module role. + +Prefer a self-contained profile document for this first interchange format. +If references are used internally, validate that required references resolve +within the document/catalog and cannot silently bind to an unrelated revision. +Avoid a generic entity/definition framework or arbitrary property-bag domain. + +### 2. Capability declarations with explicit uncertainty + +Represent operation identifiers independently of module role. Support ordinary +diagnostic/configuration/calibration/firmware/service operation declarations and +custom operation identifiers without changing a closed module-type enumeration. + +Distinguish at least Supported, Unsupported, Unknown, Inaccessible and Restricted. +Describe their meaning in documentation and retain explanatory restrictions/ +limitations and supporting provenance where supplied. + +- A missing declaration must not become Supported. Expose a documented explicit + not-declared/Unknown outcome with a reason, or an explicit lookup failure. +- Unknown, inaccessible, restricted and unsupported are not interchangeable. +- Declared support is metadata, not an implemented service, connection, permission + or physical-write authorization. +- Reject invalid statuses and duplicate/ambiguous declarations. Ensure caller + mutation cannot alter a validated profile's capabilities. + +Do not add an operation executor, a programming approval system or a real +capability-discovery implementation. + +### 3. Provenance and applicability + +Provide a practical reusable evidence representation for profile/module facts and +capability/identity metadata. It must carry: + +- Classification: VERIFIED, UNVERIFIED, INFERRED or SYNTHETIC. +- Source/reference and useful evidence description. +- Publication/retrieval information when known, supplied explicitly rather than + generated from the current clock during validation or serialization. +- Applicable vehicle/configuration/module and hardware/software/firmware or + calibration context where known. +- Confidence/verification information and known limitations; unknown confidence + is allowed explicitly rather than silently treated as certain. + +Define inheritance or reference rules so evidence is not copied everywhere while +its applicability remains unambiguous. Reject dangling evidence references, +invalid classification/confidence values, and conflicting applicability rather +than silently mixing vehicles, model years or module versions. +If confidence is numeric, document the scale and require finite in-range values, +including rejection of NaN/infinity through any direct construction path. + +Do not claim that labeling a source VERIFIED independently verifies its contents. +The system preserves supplied evidence; no online research or authority promotion +is implemented. Synthetic fixture facts/evidence must remain visibly SYNTHETIC. +No provenance status authorizes physical writes. + +### 4. Versioned JSON interchange with validation + +Implement import/export of a documented schema version 1 through Application. +Use built-in .NET JSON support unless a concrete missing capability justifies a +dependency; verify any actual API before using it. + +Requirements: + +1. Schema version is explicit and distinct from profile/configuration revision. +2. Reject missing/unsupported schema versions, malformed JSON, null/missing required + fields, invalid enum/status values, duplicate identities/capabilities, broken + references and invalid domain data. Do not silently downgrade or "repair" input. +3. Reject ambiguous duplicate JSON properties. Define an explicit unknown-property + policy; prefer rejecting unknown schema fields for v1 rather than silently + discarding identity, capability or provenance information. +4. Optional unknown information has a documented representation that round-trips + without becoming a default fact. Persist all declared statuses and provenance. +5. Deserialization must enforce the same invariants as direct domain construction; + it cannot bypass validation through setters, mutable arrays or DTO mapping. +6. Round-trip a valid profile without semantic loss, including module inventory, + unknowns, identity/revision, capability states and evidence applicability. +7. Failures are explicit and actionable with schema/property/identifier context + as appropriate. Do not log full private payloads or silently return an empty + synthetic profile. Follow existing argument/typed-exception conventions. +8. No wall-clock-generated IDs/timestamps, random behavior, network calls or hidden + file writes during import/export. In-memory string/stream interchange is enough; + no database or permanent user-file storage is required. + +The worker chooses straightforward domain and serialization representations. +If DTOs/mapping are necessary to preserve invariants, keep them local and small; +Core must not depend on DI, Application or persistence infrastructure. + +### 5. Explicit catalog selection and real application composition + +Provide a narrow application service/catalog that accepts validated profiles, +lists available configuration identities and resolves an explicitly requested +profile/configuration identifier and revision. +Expose these behaviors through cohesive feature operations; an in-memory +feature-local catalog is sufficient. Do not introduce generic repositories or +permanent database/file storage. Keep any selected configuration explicit to the +request/presentation scope rather than a mutable global execution mode. + +- Support multiple vehicles and multiple saved variants of one vehicle. +- Reject duplicate keys under the documented identity rule. An exact unknown + revision must fail even when another revision of that profile exists. +- Require explicit selection; do not choose the first/latest/closest profile, + substitute another vehicle or infer a physical execution target. +- Preserve immutable snapshots. Editing/replacing caller collections or registering + another configuration must not mutate an original validated version. +- Empty catalogs produce explicit not-found/unavailable behavior, not a fabricated + vehicle. Failed import must not partially register a profile. +- Wire through the real DI path, without changing the existing target-selection + contract or registering fake connected/available providers. + +Catalog selection is metadata selection only. It must not couple profile loading +to a global active target, a hardware connection, the UI or an AI model. + +### 6. Clearly synthetic example data + +Create source-controlled schema-v1 fixtures under the test tree: + +- An AutoForge Synthetic Test Truck baseline with at least three differently + named module instances, including a non-powertrain role. +- A second saved configuration/revision for that vehicle with a meaningful metadata + difference, such as a distinct synthetic calibration identity. Preserve the + original baseline without modifying it. +- Test coverage for another differently shaped synthetic vehicle/inventory, + including a custom module role and operation identifier. + +Across the fixtures/tests, exercise all five capability states and at least one +unknown optional identity. Supply explicit synthetic provenance and limitations. +Do not claim real manufacturer compatibility, use private VINs, invent authentic +diagnostic commands/offsets, or put synthetic fixture data in ignored local-data. +Fixtures describe metadata, not real services or working simulation. + +Avoid duplicated fixture copies between test projects or an unnecessary shared +test-helper assembly. Use a simple existing test-tree arrangement. + +### 7. Minimal profile UI in the existing application + +Add a profile metadata feature page, for example `/vehicle-profiles`, under +AutoForge.UI's feature organization, plus a navigation entry in the existing +layout. Do not move routing/pages into Client or restructure the shell. + +- Provide a simple JSON text input for explicit import, an available-profile/ + revision listing and explicit selection, and a read-only metadata inspection/ + JSON export area. No OS file picker, persistent user files or auto-loaded real + vehicle database is needed. +- Invoke the same application import/list/select/export operations tested + headlessly. Presentation adapts inputs and displays errors; domain/schema + validation remains in Core/Application. +- Show module identities, declared capability states, unknown information, + provenance and synthetic limitations accurately. Reuse StatusNotice. +- Do not silently select the first/latest/imported configuration, mutate a + previously selected baseline, or change execution-target/provider registration. +- Invalid JSON, unsupported schema, duplicate import and unknown selection must + produce explicit visible errors without partial registration or replacement. +- Do not claim a loaded profile is connected, a supported service is implemented, + or a synthetic calibration identity is firmware/tune data. +- Restrict Client changes to necessary feature DI composition; add no second + executable, backend, native adapter, fake provider or placeholder future screen. + +## FILES OR PROJECTS EXPECTED TO CHANGE + +- Add domain models/validation to `src/AutoForge.Core`. +- Add feature-organized JSON interchange/catalog operations and DI wiring under + `src/AutoForge.Application/Features`. +- Add profile feature presentation and navigation in `src/AutoForge.UI`; reuse + Components. Touch Client only for necessary in-process DI composition. +- Extend both existing test projects; place synthetic fixtures under `src/tests`. +- Update root README and relevant documentation under `docs`. +- Update dependency/build configuration only if necessary, with a specific rationale. +- Create only `prompts/Step-02-Report.md` under `prompts`. + +Do not modify roadmap/state/assignments or prior worker reports. Do not modify or +create `.github/copilot-instructions.md`, or alternative override instructions. +Preserve existing uncommitted changes. Do not stage, commit, push or initialize Git. + +## INTERFACE AND DEPENDENCY REQUIREMENTS + +- Keep all seven existing projects and corrected reference direction. No new + framework, database, host, adapter, RCL, knowledge service or test project is needed. +- Reuse existing validation/error/DI patterns where applicable without forcing + unrelated abstractions. Keep the explicit-target service behavior unchanged. +- Profile/module/capability identity is data-driven. Unknown facts cannot enable + support or authorize execution, and provenance cannot override access restrictions. +- Use strongly typed models and immutable/snapshotted collections. Do not expose + backing arrays/lists/dictionaries that bypass validation. +- Use the installed SDK/test stack and existing central pins. Do not install + packages preemptively or retarget to another framework. +- Application/domain tests remain independent of UI/native startup. UI tests render + the actual portable RCL without Client. No external service, inference, cloud + account, device, model, wall-clock data input or uncontrolled randomness is needed. +- Do not add a simulation ground-truth shortcut to ordinary application models. + +## TESTING REQUIREMENTS + +### Unit tests + +Cover domain construction and use-case behavior, including: + +- Required identifiers, valid optional values, invalid revisions/year/confidence/ + classification/status values and null/missing data where applicable. +- Multiple modules with the same role but distinct instance IDs; duplicate IDs + and duplicate operation declarations fail under the documented comparison rule. +- Every capability state and explicit missing-capability behavior. +- Evidence references/applicability, unknown identities and synthetic classification. +- Input-collection mutation and immutable original configuration preservation. +- Catalog empty/unknown/duplicate selection, exact revision selection and no + cross-vehicle/first/latest fallback. +- Import/export invalid-input boundaries and semantic round-trip behavior. + +### Integration tests + +Exercise actual Core/Application/JSON/catalog feature implementations through DI: + +1. Load a synthetic fixture, validate and register it, explicitly select its exact + configuration, export/reimport it, and compare the meaningful complete model. +2. Select baseline and variant independently; verify their module/calibration + identity differences and that the baseline remains unchanged. +3. Load another vehicle/custom module/operation without changing production code. +4. Verify all five statuses, evidence classifications/applicability, explicit + unknown values and unknown-capability behavior survive round-trip. +5. Reject malformed JSON, missing/future schema, duplicate properties, invalid/ + missing required fields, duplicate module/capability IDs, invalid statuses and + dangling/conflicting evidence. Failed import cannot leave a partial catalog entry. +6. Verify unknown profile/revision and mismatched identity cannot select another + saved configuration; caller mutation cannot change the selected snapshot. +7. Compose profile services alongside the existing target resolver. Loading or + selecting a profile must not create/replace a provider or change an explicit + target selection. Retain all Step-01/Step-01A regression behaviors. +8. Render the real new profile UI with the same application feature composition; + verify metadata/unknown/status/provenance/error presentation and explicit + selection/export behavior. Do not mock the feature under test. + +Do not mock the services under test or assert only that a container returns an +object. Use exact structural assertions on identities, values, statuses, unknowns +and provenance; comparing only profile counts or JSON text is insufficient. + +### Execution evidence + +From the repository root, run the relevant focused tests while implementing, +then run the complete seven-project Release build and both suites for regression: + +- `dotnet restore .\src\AutoForge.slnx` when dependency restoration is needed. +- `dotnet build .\src\AutoForge.slnx --configuration Release --no-restore` +- `dotnet test .\src\AutoForge.slnx --configuration Release --no-build` + +Use the configured SDK and runner. Record exact commands/exit outcomes, warnings, +per-project discovered/passed/failed/skipped counts and any corrected failures. +Preserve the accepted 54 Step-01 cases/invariants and add substantive new coverage; +also preserve the 11 additional Step-01A rendered/graph cases (65 total baseline). +Do not remove checks or skip acceptance tests to produce a green report. + +Build the real Windows Client as well if a direct native command is needed to +diagnose target/runtime issues. Use the existing verified Windows TFM; do not +apply a Windows framework override to portable projects. The established +runtime-specific package restore may be needed after manifest changes: +`dotnet restore .\src\AutoForge.Client\AutoForge.Client.csproj --runtime win-x64`. +This is package restore, not permission to change installed workloads. + +### Native profile-feature smoke + +Launch the actual Client on the existing supported Windows desktop. Navigate to +the new profile page, import synthetic fixture JSON, explicitly select baseline +and variant, inspect module/capability/provenance/unknown metadata, and export a +selected configuration. Confirm invalid/duplicate input is visible and does not +replace valid data or change target selection. Verify existing home/target/not-found +routes remain functional. Record observations separately from headless tests. +If native execution/build becomes unavailable, report the exact blocker and +unexecuted check honestly; do not substitute a web host or claim full completion. + +Report durable evidence in the step report, with optional ignored result files +under `src`. The orchestrator will inspect it without executing builds/tests. +Finish with a Git status/diff and protected-file/scope review; do not discard +unrelated work or perform destructive cleanup. + +## DOCUMENTATION REQUIREMENTS + +Update the documentation index, architecture, build/test guidance and root README +to describe actual implemented profile/module/provenance/interchange/catalog +behavior and its limitations. Add concise schema-v1/profile documentation with: + +- Model responsibilities, identifier/revision semantics and unknown representation. +- The five capability states, missing declaration behavior and no authorization. +- Provenance references/inheritance/applicability, validation and confidence rules. +- JSON schema shape, required/optional fields, unknown/duplicate property policy, + supported version, explicit unsupported-version outcome and future migration rule. +- Synthetic fixture purpose, provenance and how to exercise the application path. +- Immutable version selection and error outcomes. +- Application slice and UI ownership, in-memory/session-only lifetime, explicit + selection, synthetic import/export walkthrough and native smoke procedure. + +Record a focused ADR only for a significant new decision, such as persisted +schema/versioning rules; do not create empty future-feature documents. + +Align README and existing ADR lifecycle text with Step-01A's acceptance, clearly +distinguish Step-02 worker completion from pending orchestrator acceptance, and +preserve prior reports as historical evidence. Preserve the real native Client +startup/build commands; profiles are metadata only, not a diagnostic transport, +simulator or hardware support. Retain one Client/two RCLs and no backend. +Normalize the README's line endings as noted above; do not change global Git +settings or rewrite unrelated historical files to conceal whitespace warnings. + +## ACCEPTANCE CRITERIA + +| ID | Criterion | Required evidence | +|---|---|---| +| AC-01 | Existing repository, seven-project single-shell/RCL/VSA architecture, accepted target behavior and manual/protected workflow preserved; no shell restructuring or new assembly | Git/scope/reference review and all 65 baseline regression results | +| AC-02 | Validated versioned profiles model multiple vehicles/configurations, arbitrary module roles, identities and calibration references with explicit unknowns | Source paths and positive/negative domain tests | +| AC-03 | All five capability states, extensible operation IDs, duplicate rejection and explicit missing declarations work without granting operational authority | Behavior tests and documented status contract | +| AC-04 | Provenance classifications, sources, confidence/verification/limitations and applicable identity context round-trip; invalid/conflicting references fail | Model/schema documentation and evidence validation tests | +| AC-05 | Schema-v1 JSON import/export preserves semantic data and enforces domain invariants; malformed/missing/future/ambiguous data fail explicitly | Full round-trip and enumerated rejection tests | +| AC-06 | Feature-organized real DI path supports exact profile/revision selection, empty/unknown/duplicate failure, immutable originals and atomic import; thin real UI consumes it without target fallback | Source paths, application/rendered integration assertions and native profile smoke | +| AC-07 | Clearly synthetic baseline/variant and alternate-vehicle coverage prove data-driven module/operation handling without manufacturer claims | Visible fixture paths and integration evidence | +| AC-08 | Seven-project Release/native build, both suites with all accepted/new cases and native UI smoke succeed; no required skipped/zero-discovery cases | Exact commands/targets/outcomes, warnings, per-project counts and native observations | +| AC-09 | README/index/architecture/schema guidance match implemented scope, lifecycle and existing Markdown convention; prior reports unchanged | Documentation/preservation summary and line-ending check | +| AC-10 | Complete Step-02 report saved at the required path; worker stops without changing orchestration files or starting Step-03 | Report sections, acceptance table and Git review | + +Map every criterion to PASSED, FAILED, NOT EXECUTED or BLOCKED with concrete +evidence. Overall COMPLETE requires every criterion and required execution to +succeed. State unresolved failures and environment blockers explicitly. + +## OUT-OF-SCOPE WORK + +Simulation/dynamics/virtual modules, diagnostics/protocols/transports, telemetry, +recording/replay, calibration definitions/values/editing/programming/backups, +runbooks/approval execution, real hardware/drivers, new/restructured UI hosts/RCLs, databases, +knowledge research/RAG/AI/model downloads, MCP, containers and cloud infrastructure. +No authentic manufacturer definitions or online vehicle research are needed. +No operation intended to defeat emissions, bypass anti-theft, falsify mileage or +disable safety systems is permitted. + +## REPORTING REQUIREMENTS + +Create `prompts/Step-02-Report.md`, entirely inside exactly one plain triple-backtick +code fence, without a language tag or content outside it. Use no nested fences. +Use the same copy-window format for the final chat report. + +Include: + +1. Step identifier/title and COMPLETE, INCOMPLETE or BLOCKED status. +2. Implemented functionality and explicit distinction from planned functionality. +3. Files created and modified; pre-existing/concurrent changes preserved. +4. Architectural/project/dependency changes and new public contracts/error behavior. +5. Schema/identifier/revision/unknown/capability/provenance decisions and limitations. +6. Unit tests created/modified and their behavior coverage. +7. Integration tests created/modified and actual boundaries/assertions exercised. +8. Environment/SDK/package/runner choices and any necessary changes. +9. Exact restore/build commands/results, exit outcomes and warnings/errors. +10. Exact test commands/results, per-project counts, prior regression preservation + and any failed/skipped/unexecuted cases. + Include native profile-feature launch/interaction observations separately. +11. AC-01 through AC-10 evidence table. +12. Documentation changes and root README changes. +13. Known limitations, outstanding issues/blockers and corrected failures. +14. Deviations and rationale; relevant recommendations for review. +15. Protected assignment/report/orchestration preservation and final Git review. + Include README line-ending verification and confirm no workload-changing + inspection/installation/update/rollback command was invoked. + +Never claim unexecuted tests passed or metadata proves operational compatibility. +After saving the report, STOP. Do not change assignments/roadmap/state, create +Step-03, invoke another agent, automate handoff, stage, commit or push. diff --git a/src/AutoForge.Application/AutoForge.Application.csproj b/src/AutoForge.Application/AutoForge.Application.csproj new file mode 100644 index 0000000..4772658 --- /dev/null +++ b/src/AutoForge.Application/AutoForge.Application.csproj @@ -0,0 +1,15 @@ + + + + + + + + net10.0 + + + + + + + diff --git a/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetResolver.cs b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetResolver.cs new file mode 100644 index 0000000..2ecc17f --- /dev/null +++ b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetResolver.cs @@ -0,0 +1,53 @@ +using AutoForge.Core.ExecutionTargets; + +namespace AutoForge.Application.ExecutionTargets; + +public sealed class ExecutionTargetResolver : IExecutionTargetResolver +{ + private readonly Dictionary registrations = + new(StringComparer.OrdinalIgnoreCase); + + public ExecutionTargetResolver(IEnumerable registrations) + { + ArgumentNullException.ThrowIfNull(registrations); + + foreach (var descriptor in registrations) + { + if (descriptor is null) + { + throw new ArgumentException("Registrations cannot contain null descriptors.", nameof(registrations)); + } + + if (!this.registrations.TryAdd(descriptor.ProviderIdentifier, descriptor)) + { + throw new TargetSelectionException( + TargetSelectionFailure.DuplicateProviderIdentifier, + $"Provider identifier '{descriptor.ProviderIdentifier}' is registered more than once. " + + "Use unique identifiers under ordinal case-insensitive comparison, even across target kinds."); + } + } + } + + public ExecutionTargetDescriptor Resolve(ExecutionTargetDescriptor selection) + { + ArgumentNullException.ThrowIfNull(selection); + + if (!registrations.TryGetValue(selection.ProviderIdentifier, out var descriptor)) + { + throw new TargetSelectionException( + TargetSelectionFailure.ProviderNotRegistered, + $"Provider '{selection.ProviderIdentifier}' is not registered. " + + "Supply an explicitly registered provider identifier and target kind."); + } + + if (descriptor.Kind != selection.Kind) + { + throw new TargetSelectionException( + TargetSelectionFailure.KindMismatch, + $"Provider '{selection.ProviderIdentifier}' is registered for {descriptor.Kind}, " + + $"not the requested {selection.Kind}. Select the correct provider explicitly; no fallback is allowed."); + } + + return descriptor; + } +} diff --git a/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/IExecutionTargetResolver.cs b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/IExecutionTargetResolver.cs new file mode 100644 index 0000000..c998b89 --- /dev/null +++ b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/IExecutionTargetResolver.cs @@ -0,0 +1,9 @@ +using AutoForge.Core.ExecutionTargets; + +namespace AutoForge.Application.ExecutionTargets; + +/// Resolves an explicit provider identifier and kind without substituting another target. +public interface IExecutionTargetResolver +{ + ExecutionTargetDescriptor Resolve(ExecutionTargetDescriptor selection); +} diff --git a/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ServiceCollectionExtensions.cs b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ServiceCollectionExtensions.cs new file mode 100644 index 0000000..91d9e66 --- /dev/null +++ b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/ServiceCollectionExtensions.cs @@ -0,0 +1,25 @@ +using AutoForge.Core.ExecutionTargets; +using Microsoft.Extensions.DependencyInjection; + +namespace AutoForge.Application.ExecutionTargets; + +/// Composes the explicit target-selection feature from validated metadata registrations. +public static class ServiceCollectionExtensions +{ + public static IServiceCollection AddAutoForgeTargetSelection( + this IServiceCollection services, + IEnumerable registrations) + { + ArgumentNullException.ThrowIfNull(services); + + if (services.Any(service => service.ServiceType == typeof(IExecutionTargetResolver))) + { + throw new InvalidOperationException( + "Target selection is already registered. Supply all descriptors in a single registration call."); + } + + var resolver = new ExecutionTargetResolver(registrations); + services.AddSingleton(resolver); + return services; + } +} diff --git a/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionException.cs b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionException.cs new file mode 100644 index 0000000..b06183e --- /dev/null +++ b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionException.cs @@ -0,0 +1,13 @@ +namespace AutoForge.Application.ExecutionTargets; + +/// Reports why an explicit target selection could not be resolved. +public sealed class TargetSelectionException : InvalidOperationException +{ + public TargetSelectionException(TargetSelectionFailure failure, string message) + : base(message) + { + Failure = failure; + } + + public TargetSelectionFailure Failure { get; } +} diff --git a/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionFailure.cs b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionFailure.cs new file mode 100644 index 0000000..645397d --- /dev/null +++ b/src/AutoForge.Application/Features/ExecutionTargets/SelectExecutionTarget/TargetSelectionFailure.cs @@ -0,0 +1,9 @@ +namespace AutoForge.Application.ExecutionTargets; + +/// Identifies an explicit target-selection failure. +public enum TargetSelectionFailure +{ + ProviderNotRegistered = 1, + KindMismatch = 2, + DuplicateProviderIdentifier = 3 +} diff --git a/src/AutoForge.Client/.gitignore b/src/AutoForge.Client/.gitignore new file mode 100644 index 0000000..4d0b05a --- /dev/null +++ b/src/AutoForge.Client/.gitignore @@ -0,0 +1,11 @@ +# Build outputs +bin/ +obj/ + +# User-specific files +.vs/ +*.user +*.suo + +# OS-generated files +.DS_Store diff --git a/src/AutoForge.Client/App.xaml b/src/AutoForge.Client/App.xaml new file mode 100644 index 0000000..093054e --- /dev/null +++ b/src/AutoForge.Client/App.xaml @@ -0,0 +1,17 @@ + + + + + + + + + + diff --git a/src/AutoForge.Client/App.xaml.cs b/src/AutoForge.Client/App.xaml.cs new file mode 100644 index 0000000..8231a7c --- /dev/null +++ b/src/AutoForge.Client/App.xaml.cs @@ -0,0 +1,14 @@ +namespace AutoForge.Client; + +public partial class App : Microsoft.Maui.Controls.Application +{ + public App() + { + InitializeComponent(); + } + + protected override Window CreateWindow(IActivationState? activationState) + { + return new Window(new MainPage()) { Title = "AutoForge" }; + } +} diff --git a/src/AutoForge.Client/AutoForge.Client.csproj b/src/AutoForge.Client/AutoForge.Client.csproj new file mode 100644 index 0000000..f15456c --- /dev/null +++ b/src/AutoForge.Client/AutoForge.Client.csproj @@ -0,0 +1,67 @@ + + + + net10.0-windows10.0.26100.0 + Exe + AutoForge.Client + true + true + enable + + false + enable + + + SourceGen + + + AutoForge + + + com.companyname.autoforge.client + + + 1.0 + 1 + + + None + + 10.0.17763.0 + 10.0.17763.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/AutoForge.Client/MainPage.xaml b/src/AutoForge.Client/MainPage.xaml new file mode 100644 index 0000000..d27ffd2 --- /dev/null +++ b/src/AutoForge.Client/MainPage.xaml @@ -0,0 +1,13 @@ + + + + + + + + + + diff --git a/src/AutoForge.Client/MainPage.xaml.cs b/src/AutoForge.Client/MainPage.xaml.cs new file mode 100644 index 0000000..ba5f550 --- /dev/null +++ b/src/AutoForge.Client/MainPage.xaml.cs @@ -0,0 +1,9 @@ +namespace AutoForge.Client; + +public partial class MainPage : ContentPage +{ + public MainPage() + { + InitializeComponent(); + } +} diff --git a/src/AutoForge.Client/MauiProgram.cs b/src/AutoForge.Client/MauiProgram.cs new file mode 100644 index 0000000..5be23ae --- /dev/null +++ b/src/AutoForge.Client/MauiProgram.cs @@ -0,0 +1,27 @@ +using Microsoft.Extensions.Logging; +using AutoForge.Application.ExecutionTargets; +using AutoForge.UI; + +namespace AutoForge.Client; + +public static class MauiProgram +{ + public static MauiApp CreateMauiApp() + { + var builder = MauiApp.CreateBuilder(); + builder + .UseMauiApp() + .ConfigureFonts(fonts => fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular")); + + builder.Services.AddAutoForgeTargetSelection([]); + builder.Services.AddAutoForgeUi(); + builder.Services.AddMauiBlazorWebView(); + +#if DEBUG + builder.Services.AddBlazorWebViewDeveloperTools(); + builder.Logging.AddDebug(); +#endif + + return builder.Build(); + } +} diff --git a/src/AutoForge.Client/Platforms/Windows/App.xaml b/src/AutoForge.Client/Platforms/Windows/App.xaml new file mode 100644 index 0000000..bcb5975 --- /dev/null +++ b/src/AutoForge.Client/Platforms/Windows/App.xaml @@ -0,0 +1,8 @@ + + + diff --git a/src/AutoForge.Client/Platforms/Windows/App.xaml.cs b/src/AutoForge.Client/Platforms/Windows/App.xaml.cs new file mode 100644 index 0000000..c9fa7f9 --- /dev/null +++ b/src/AutoForge.Client/Platforms/Windows/App.xaml.cs @@ -0,0 +1,24 @@ +using Microsoft.UI.Xaml; + +// To learn more about WinUI, the WinUI project structure, +// and more about our project templates, see: http://aka.ms/winui-project-info. + +namespace AutoForge.Client.WinUI; + +/// +/// Provides application-specific behavior to supplement the default Application class. +/// +public partial class App : MauiWinUIApplication +{ + /// + /// Initializes the singleton application object. This is the first line of authored code + /// executed, and as such is the logical equivalent of main() or WinMain(). + /// + public App() + { + this.InitializeComponent(); + } + + protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp(); +} + diff --git a/src/AutoForge.Client/Platforms/Windows/Package.appxmanifest b/src/AutoForge.Client/Platforms/Windows/Package.appxmanifest new file mode 100644 index 0000000..afdcd55 --- /dev/null +++ b/src/AutoForge.Client/Platforms/Windows/Package.appxmanifest @@ -0,0 +1,46 @@ + + + + + + + + + $placeholder$ + User Name + $placeholder$.png + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/AutoForge.Client/Platforms/Windows/app.manifest b/src/AutoForge.Client/Platforms/Windows/app.manifest new file mode 100644 index 0000000..cfcf2d1 --- /dev/null +++ b/src/AutoForge.Client/Platforms/Windows/app.manifest @@ -0,0 +1,17 @@ + + + + + + + + true/PM + PerMonitorV2, PerMonitor + + true + + + diff --git a/src/AutoForge.Client/Properties/launchSettings.json b/src/AutoForge.Client/Properties/launchSettings.json new file mode 100644 index 0000000..4f85793 --- /dev/null +++ b/src/AutoForge.Client/Properties/launchSettings.json @@ -0,0 +1,8 @@ +{ + "profiles": { + "Windows Machine": { + "commandName": "Project", + "nativeDebugging": false + } + } +} \ No newline at end of file diff --git a/src/AutoForge.Client/Resources/AppIcon/appicon.svg b/src/AutoForge.Client/Resources/AppIcon/appicon.svg new file mode 100644 index 0000000..9d63b65 --- /dev/null +++ b/src/AutoForge.Client/Resources/AppIcon/appicon.svg @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/src/AutoForge.Client/Resources/AppIcon/appiconfg.svg b/src/AutoForge.Client/Resources/AppIcon/appiconfg.svg new file mode 100644 index 0000000..21dfb25 --- /dev/null +++ b/src/AutoForge.Client/Resources/AppIcon/appiconfg.svg @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/src/AutoForge.Client/Resources/Fonts/OpenSans-Regular.ttf b/src/AutoForge.Client/Resources/Fonts/OpenSans-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f733c4b8b39f6ff4815f281bd110a24c3de1aa52 GIT binary patch literal 107048 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 S6*#|`kcW7O+bmO6kM%#GS~9Qz literal 0 HcmV?d00001 diff --git a/src/AutoForge.Client/Resources/Raw/AboutAssets.txt b/src/AutoForge.Client/Resources/Raw/AboutAssets.txt new file mode 100644 index 0000000..6de1c15 --- /dev/null +++ b/src/AutoForge.Client/Resources/Raw/AboutAssets.txt @@ -0,0 +1,15 @@ +Any raw assets you want to be deployed with your application can be placed in +this directory (and child directories). Deployment of the asset to your application +is automatically handled by the following `MauiAsset` Build Action within your `.csproj`. + + + +These files will be deployed with your package and will be accessible using Essentials: + + async Task LoadMauiAsset() + { + using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt"); + using var reader = new StreamReader(stream); + + var contents = reader.ReadToEnd(); + } diff --git a/src/AutoForge.Client/Resources/Splash/splash.svg b/src/AutoForge.Client/Resources/Splash/splash.svg new file mode 100644 index 0000000..21dfb25 --- /dev/null +++ b/src/AutoForge.Client/Resources/Splash/splash.svg @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/src/AutoForge.Client/wwwroot/index.html b/src/AutoForge.Client/wwwroot/index.html new file mode 100644 index 0000000..1dc54ff --- /dev/null +++ b/src/AutoForge.Client/wwwroot/index.html @@ -0,0 +1,27 @@ + + + + + + AutoForge + + + + + + + + +
Loading AutoForge...
+ +
+ + + + + + \ No newline at end of file diff --git a/src/AutoForge.Components/AutoForge.Components.csproj b/src/AutoForge.Components/AutoForge.Components.csproj new file mode 100644 index 0000000..db40762 --- /dev/null +++ b/src/AutoForge.Components/AutoForge.Components.csproj @@ -0,0 +1,14 @@ + + + + net10.0 + enable + enable + + + + + + + + diff --git a/src/AutoForge.Components/StatusNotice.razor b/src/AutoForge.Components/StatusNotice.razor new file mode 100644 index 0000000..c470db9 --- /dev/null +++ b/src/AutoForge.Components/StatusNotice.razor @@ -0,0 +1,15 @@ +
+ @Message +
+ +@code { + [Parameter, EditorRequired] + public string Message { get; set; } = string.Empty; + + [Parameter] + public StatusNoticeTone Tone { get; set; } = StatusNoticeTone.Information; + + private string ToneName => Tone.ToString().ToLowerInvariant(); + + private string CssClass => $"status-notice status-notice--{ToneName}"; +} diff --git a/src/AutoForge.Components/StatusNotice.razor.css b/src/AutoForge.Components/StatusNotice.razor.css new file mode 100644 index 0000000..a01bbd5 --- /dev/null +++ b/src/AutoForge.Components/StatusNotice.razor.css @@ -0,0 +1,25 @@ +.status-notice { + border: 1px solid currentColor; + border-radius: 0.375rem; + padding: 0.75rem 1rem; +} + +.status-notice--information { + color: #174a73; + background: #eaf4fb; +} + +.status-notice--success { + color: #205b35; + background: #eaf6ed; +} + +.status-notice--warning { + color: #684d00; + background: #fff7db; +} + +.status-notice--error { + color: #7c2525; + background: #fdecec; +} diff --git a/src/AutoForge.Components/StatusNoticeTone.cs b/src/AutoForge.Components/StatusNoticeTone.cs new file mode 100644 index 0000000..6e913da --- /dev/null +++ b/src/AutoForge.Components/StatusNoticeTone.cs @@ -0,0 +1,9 @@ +namespace AutoForge.Components; + +public enum StatusNoticeTone +{ + Information, + Success, + Warning, + Error +} diff --git a/src/AutoForge.Components/_Imports.razor b/src/AutoForge.Components/_Imports.razor new file mode 100644 index 0000000..b91e21b --- /dev/null +++ b/src/AutoForge.Components/_Imports.razor @@ -0,0 +1,2 @@ +@using Microsoft.AspNetCore.Components.Web +@using Microsoft.AspNetCore.Components diff --git a/src/AutoForge.Core/AutoForge.Core.csproj b/src/AutoForge.Core/AutoForge.Core.csproj new file mode 100644 index 0000000..00b9359 --- /dev/null +++ b/src/AutoForge.Core/AutoForge.Core.csproj @@ -0,0 +1,7 @@ + + + + net10.0 + + + diff --git a/src/AutoForge.Core/ExecutionTargets/ExecutionTargetDescriptor.cs b/src/AutoForge.Core/ExecutionTargets/ExecutionTargetDescriptor.cs new file mode 100644 index 0000000..eb165ae --- /dev/null +++ b/src/AutoForge.Core/ExecutionTargets/ExecutionTargetDescriptor.cs @@ -0,0 +1,28 @@ +namespace AutoForge.Core.ExecutionTargets; + +public sealed class ExecutionTargetDescriptor +{ + public ExecutionTargetDescriptor(string providerIdentifier, ExecutionTargetKind kind) + { + ArgumentException.ThrowIfNullOrWhiteSpace(providerIdentifier); + + if (providerIdentifier != providerIdentifier.Trim()) + { + throw new ArgumentException( + "Provider identifiers must not contain leading or trailing whitespace.", + nameof(providerIdentifier)); + } + + if (!Enum.IsDefined(kind)) + { + throw new ArgumentOutOfRangeException(nameof(kind), kind, "Specify a defined execution-target kind."); + } + + ProviderIdentifier = providerIdentifier; + Kind = kind; + } + + public string ProviderIdentifier { get; } + + public ExecutionTargetKind Kind { get; } +} diff --git a/src/AutoForge.Core/ExecutionTargets/ExecutionTargetKind.cs b/src/AutoForge.Core/ExecutionTargets/ExecutionTargetKind.cs new file mode 100644 index 0000000..bd9676e --- /dev/null +++ b/src/AutoForge.Core/ExecutionTargets/ExecutionTargetKind.cs @@ -0,0 +1,8 @@ +namespace AutoForge.Core.ExecutionTargets; + +public enum ExecutionTargetKind +{ + Simulation = 1, + RecordedReplay = 2, + PhysicalHardware = 3 +} diff --git a/src/AutoForge.UI/AutoForge.UI.csproj b/src/AutoForge.UI/AutoForge.UI.csproj new file mode 100644 index 0000000..f9b1add --- /dev/null +++ b/src/AutoForge.UI/AutoForge.UI.csproj @@ -0,0 +1,19 @@ + + + + net10.0 + enable + enable + + + + + + + + + + + + + diff --git a/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor b/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor new file mode 100644 index 0000000..f8515c1 --- /dev/null +++ b/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor @@ -0,0 +1,41 @@ +@page "/execution-targets" +@inject ExecutionTargetSelectionViewModel Selection + +Execution-target selection - AutoForge + +

Select execution-target metadata

+

+ Enter both values explicitly. Resolution checks registered metadata only; + selection does not connect to a vehicle, execute an operation or grant write approval. +

+ + + +
+ + + + + + + +
+ +@if (Selection.SelectedDescriptor is { } descriptor) +{ +

+ Resolved registered metadata for @descriptor.ProviderIdentifier (@descriptor.Kind). + No connection or operation was performed. +

+} + +@code { + private void Submit() => Selection.Select(); +} diff --git a/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor.css b/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor.css new file mode 100644 index 0000000..a0a11bd --- /dev/null +++ b/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionPage.razor.css @@ -0,0 +1,30 @@ +.selection-form { + display: grid; + gap: 0.75rem; + margin-top: 1.5rem; + max-width: 32rem; +} + +.selection-form input, +.selection-form select { + border: 1px solid #66788a; + border-radius: 0.25rem; + font: inherit; + padding: 0.6rem; +} + +.selection-form button { + background: #14283f; + border: 0; + border-radius: 0.25rem; + color: #fff; + cursor: pointer; + font: inherit; + justify-self: start; + margin-top: 0.5rem; + padding: 0.65rem 1rem; +} + +.selection-result { + margin-top: 1rem; +} diff --git a/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionViewModel.cs b/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionViewModel.cs new file mode 100644 index 0000000..3ff02da --- /dev/null +++ b/src/AutoForge.UI/Features/ExecutionTargets/SelectExecutionTarget/ExecutionTargetSelectionViewModel.cs @@ -0,0 +1,62 @@ +using AutoForge.Application.ExecutionTargets; +using AutoForge.Components; +using AutoForge.Core.ExecutionTargets; + +namespace AutoForge.UI.Features.ExecutionTargets.SelectExecutionTarget; + +public sealed class ExecutionTargetSelectionViewModel(IExecutionTargetResolver resolver) +{ + public string ProviderIdentifier { get; set; } = string.Empty; + + public ExecutionTargetKind? SelectedKind { get; set; } + + public ExecutionTargetDescriptor? SelectedDescriptor { get; private set; } + + public bool HasAttemptedSelection { get; private set; } + + public StatusNoticeTone StatusTone { get; private set; } = StatusNoticeTone.Warning; + + public string StatusMessage { get; private set; } = + "No provider metadata is registered. Choose an explicit provider identifier and target kind; selection will fail until a provider is configured. No connection is attempted."; + + public void Select() + { + SelectedDescriptor = null; + HasAttemptedSelection = true; + + if (string.IsNullOrWhiteSpace(ProviderIdentifier)) + { + SetFailure("Enter an explicit provider identifier."); + return; + } + + if (SelectedKind is null) + { + SetFailure("Choose an explicit execution-target kind."); + return; + } + + try + { + var selection = new ExecutionTargetDescriptor(ProviderIdentifier, SelectedKind.Value); + SelectedDescriptor = resolver.Resolve(selection); + StatusTone = StatusNoticeTone.Success; + StatusMessage = + $"Metadata selected: {SelectedDescriptor.ProviderIdentifier} ({SelectedDescriptor.Kind}). This does not connect to a vehicle or authorize an operation."; + } + catch (TargetSelectionException exception) + { + SetFailure(exception.Message); + } + catch (ArgumentException exception) + { + SetFailure(exception.Message); + } + } + + private void SetFailure(string message) + { + StatusTone = StatusNoticeTone.Error; + StatusMessage = message; + } +} diff --git a/src/AutoForge.UI/Features/Foundation/AddAutoForgeUi.cs b/src/AutoForge.UI/Features/Foundation/AddAutoForgeUi.cs new file mode 100644 index 0000000..7b04f7d --- /dev/null +++ b/src/AutoForge.UI/Features/Foundation/AddAutoForgeUi.cs @@ -0,0 +1,15 @@ +using AutoForge.UI.Features.ExecutionTargets.SelectExecutionTarget; +using Microsoft.Extensions.DependencyInjection; + +namespace AutoForge.UI; + +public static class ServiceCollectionExtensions +{ + public static IServiceCollection AddAutoForgeUi(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + + services.AddScoped(); + return services; + } +} diff --git a/src/AutoForge.UI/Features/Foundation/Home.razor b/src/AutoForge.UI/Features/Foundation/Home.razor new file mode 100644 index 0000000..41313da --- /dev/null +++ b/src/AutoForge.UI/Features/Foundation/Home.razor @@ -0,0 +1,14 @@ +@page "/" + +AutoForge + +

AutoForge foundation

+

+ The application shell is ready for future, independently testable feature slices. + No vehicle, driver, model, backend or cloud service is required to start. +

+ +

+ Review execution-target selection +

diff --git a/src/AutoForge.UI/Features/Foundation/NotFoundPage.razor b/src/AutoForge.UI/Features/Foundation/NotFoundPage.razor new file mode 100644 index 0000000..725fbca --- /dev/null +++ b/src/AutoForge.UI/Features/Foundation/NotFoundPage.razor @@ -0,0 +1,5 @@ +Page not found - AutoForge + +

Page not found

+ diff --git a/src/AutoForge.UI/Layout/MainLayout.razor b/src/AutoForge.UI/Layout/MainLayout.razor new file mode 100644 index 0000000..fcdee14 --- /dev/null +++ b/src/AutoForge.UI/Layout/MainLayout.razor @@ -0,0 +1,19 @@ +@inherits LayoutComponentBase + +
+ + +
+ @Body +
+ +
+ Target selection is metadata only; it does not connect to a vehicle or authorize an operation. +
+
diff --git a/src/AutoForge.UI/Layout/MainLayout.razor.css b/src/AutoForge.UI/Layout/MainLayout.razor.css new file mode 100644 index 0000000..f70ca83 --- /dev/null +++ b/src/AutoForge.UI/Layout/MainLayout.razor.css @@ -0,0 +1,51 @@ +.app-shell { + display: flex; + min-height: 100vh; + flex-direction: column; +} + +.site-header { + align-items: center; + background: #14283f; + color: #fff; + display: flex; + gap: 2rem; + padding: 1rem clamp(1rem, 5vw, 4rem); +} + +.brand { + color: inherit; + font-size: 1.25rem; + font-weight: 700; + text-decoration: none; +} + +nav { + display: flex; + gap: 1rem; +} + +nav a { + color: #d6e4f2; + text-decoration: none; +} + +nav a.active { + color: #fff; + text-decoration: underline; + text-underline-offset: 0.25rem; +} + +main { + flex: 1; + margin: 0 auto; + max-width: 64rem; + padding: 2rem clamp(1rem, 5vw, 4rem); + width: 100%; +} + +footer { + border-top: 1px solid #d5dce4; + color: #384b5f; + padding: 1rem clamp(1rem, 5vw, 4rem); +} diff --git a/src/AutoForge.UI/Routes.razor b/src/AutoForge.UI/Routes.razor new file mode 100644 index 0000000..085fffd --- /dev/null +++ b/src/AutoForge.UI/Routes.razor @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/src/AutoForge.UI/_Imports.razor b/src/AutoForge.UI/_Imports.razor new file mode 100644 index 0000000..518ab17 --- /dev/null +++ b/src/AutoForge.UI/_Imports.razor @@ -0,0 +1,7 @@ +@using Microsoft.AspNetCore.Components +@using Microsoft.AspNetCore.Components.Routing +@using Microsoft.AspNetCore.Components.Web +@using AutoForge.Components +@using AutoForge.Core.ExecutionTargets +@using AutoForge.UI.Features.Foundation +@using AutoForge.UI.Features.ExecutionTargets.SelectExecutionTarget diff --git a/src/AutoForge.UI/wwwroot/app.css b/src/AutoForge.UI/wwwroot/app.css new file mode 100644 index 0000000..e42f9e8 --- /dev/null +++ b/src/AutoForge.UI/wwwroot/app.css @@ -0,0 +1,45 @@ +:root { + color: #1d2b38; + font-family: "Segoe UI", Arial, sans-serif; + line-height: 1.5; +} + +* { + box-sizing: border-box; +} + +body { + margin: 0; +} + +#blazor-error-ui { + background: #fff3cd; + bottom: 0; + box-shadow: 0 -1px 2px rgb(0 0 0 / 20%); + box-sizing: border-box; + display: none; + left: 0; + padding: 0.75rem 1rem; + position: fixed; + width: 100%; + z-index: 1000; +} + +#blazor-error-ui .dismiss { + cursor: pointer; + position: absolute; + right: 0.75rem; + top: 0.5rem; +} + +a { + color: #155c91; +} + +a:focus-visible, +button:focus-visible, +input:focus-visible, +select:focus-visible { + outline: 3px solid #d69e00; + outline-offset: 2px; +} diff --git a/src/AutoForge.slnx b/src/AutoForge.slnx new file mode 100644 index 0000000..a709716 --- /dev/null +++ b/src/AutoForge.slnx @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/src/tests/AutoForge.IntegrationTests/AutoForge.IntegrationTests.csproj b/src/tests/AutoForge.IntegrationTests/AutoForge.IntegrationTests.csproj new file mode 100644 index 0000000..1c6711b --- /dev/null +++ b/src/tests/AutoForge.IntegrationTests/AutoForge.IntegrationTests.csproj @@ -0,0 +1,30 @@ + + + + net10.0 + false + true + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/tests/AutoForge.IntegrationTests/ProjectGraphTests.cs b/src/tests/AutoForge.IntegrationTests/ProjectGraphTests.cs new file mode 100644 index 0000000..5e4a6c3 --- /dev/null +++ b/src/tests/AutoForge.IntegrationTests/ProjectGraphTests.cs @@ -0,0 +1,115 @@ +using System.Xml.Linq; + +namespace AutoForge.IntegrationTests; + +public sealed class ProjectGraphTests +{ + [Fact] + public void Solution_ContainsOnlyTheExpectedProjectsAndDependencies() + { + var root = FindRepositoryRoot(); + var solutionPath = Path.Combine(root, "src", "AutoForge.slnx"); + var solution = XDocument.Load(solutionPath); + var projectPaths = solution.Descendants() + .Where(element => element.Name.LocalName == "Project") + .Select(element => (string?)element.Attribute("Path")) + .Where(path => path is not null) + .Select(path => Path.GetFullPath(Path.Combine(Path.GetDirectoryName(solutionPath)!, path!))) + .ToArray(); + + Assert.Equal(7, projectPaths.Length); + + var projects = projectPaths.ToDictionary( + path => Path.GetFileNameWithoutExtension(path), + LoadProject, + StringComparer.Ordinal); + + Assert.Equal( + new[] + { + "AutoForge.Application", + "AutoForge.Client", + "AutoForge.Components", + "AutoForge.Core", + "AutoForge.IntegrationTests", + "AutoForge.UI", + "AutoForge.UnitTests" + }, + projects.Keys.Order(StringComparer.Ordinal)); + + AssertReferences(projects, "AutoForge.Core"); + AssertReferences(projects, "AutoForge.Application", "AutoForge.Core"); + AssertReferences(projects, "AutoForge.Components"); + AssertReferences(projects, "AutoForge.UI", "AutoForge.Application", "AutoForge.Components"); + AssertReferences(projects, "AutoForge.Client", "AutoForge.Application", "AutoForge.UI"); + AssertReferences( + projects, + "AutoForge.UnitTests", + "AutoForge.Application", + "AutoForge.Components", + "AutoForge.Core"); + AssertReferences( + projects, + "AutoForge.IntegrationTests", + "AutoForge.Application", + "AutoForge.Components", + "AutoForge.Core", + "AutoForge.UI"); + + var executables = projects + .Where(pair => GetProperty(pair.Value, "OutputType") == "Exe") + .Select(pair => pair.Key) + .ToArray(); + Assert.Equal(["AutoForge.Client"], executables); + Assert.Equal("net10.0-windows10.0.26100.0", GetProperty(projects["AutoForge.Client"], "TargetFramework")); + Assert.Equal("true", GetProperty(projects["AutoForge.Client"], "UseMaui")); + Assert.Null(GetProperty(projects["AutoForge.Client"], "IsTestProject")); + Assert.Equal("net10.0", GetProperty(projects["AutoForge.UI"], "TargetFramework")); + Assert.Equal("net10.0", GetProperty(projects["AutoForge.Components"], "TargetFramework")); + } + + private static string FindRepositoryRoot() + { + for (var directory = new DirectoryInfo(AppContext.BaseDirectory); + directory is not null; + directory = directory.Parent) + { + if (File.Exists(Path.Combine(directory.FullName, "src", "AutoForge.slnx"))) + { + return directory.FullName; + } + } + + throw new DirectoryNotFoundException("Could not locate the AutoForge solution from the test output directory."); + } + + private static XDocument LoadProject(string projectPath) => XDocument.Load(projectPath); + + private static void AssertReferences( + IReadOnlyDictionary projects, + string projectName, + params string[] expectedReferences) + { + var document = projects[projectName]; + var projectPath = Path.Combine( + FindRepositoryRoot(), + "src", + projectName switch + { + "AutoForge.UnitTests" or "AutoForge.IntegrationTests" => + Path.Combine("tests", projectName, $"{projectName}.csproj"), + _ => Path.Combine(projectName, $"{projectName}.csproj") + }); + var actualReferences = document.Descendants() + .Where(element => element.Name.LocalName == "ProjectReference") + .Select(element => Path.GetFileNameWithoutExtension( + Path.GetFullPath(Path.Combine(Path.GetDirectoryName(projectPath)!, (string)element.Attribute("Include")!)))) + .Order(StringComparer.Ordinal) + .ToArray(); + + Assert.Equal(expectedReferences.Order(StringComparer.Ordinal), actualReferences); + } + + private static string? GetProperty(XDocument project, string propertyName) => + project.Descendants().FirstOrDefault(element => element.Name.LocalName == propertyName)?.Value; +} diff --git a/src/tests/AutoForge.IntegrationTests/TargetSelectionCompositionTests.cs b/src/tests/AutoForge.IntegrationTests/TargetSelectionCompositionTests.cs new file mode 100644 index 0000000..c9428d6 --- /dev/null +++ b/src/tests/AutoForge.IntegrationTests/TargetSelectionCompositionTests.cs @@ -0,0 +1,191 @@ +using AutoForge.Application.ExecutionTargets; +using AutoForge.Core.ExecutionTargets; +using Microsoft.Extensions.DependencyInjection; + +namespace AutoForge.IntegrationTests; + +public sealed class TargetSelectionCompositionTests +{ + [Theory] + [InlineData("synthetic.simulation", ExecutionTargetKind.Simulation)] + [InlineData("synthetic.replay", ExecutionTargetKind.RecordedReplay)] + [InlineData("synthetic.physical-metadata", ExecutionTargetKind.PhysicalHardware)] + public void Composition_ResolvesExactExplicitSyntheticMetadata(string identifier, ExecutionTargetKind kind) + { + ExecutionTargetDescriptor[] registrations = + [ + new("synthetic.simulation", ExecutionTargetKind.Simulation), + new("synthetic.replay", ExecutionTargetKind.RecordedReplay), + new("synthetic.physical-metadata", ExecutionTargetKind.PhysicalHardware) + ]; + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection(registrations); + using var provider = services.BuildServiceProvider(new ServiceProviderOptions { ValidateOnBuild = true }); + var resolver = provider.GetRequiredService(); + + var result = resolver.Resolve(new ExecutionTargetDescriptor(identifier.ToUpperInvariant(), kind)); + + Assert.Same(registrations.Single(descriptor => descriptor.ProviderIdentifier == identifier), result); + Assert.Equal(identifier, result.ProviderIdentifier); + Assert.Equal(kind, result.Kind); + } + + [Theory] + [InlineData(ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.RecordedReplay)] + [InlineData(ExecutionTargetKind.PhysicalHardware)] + public void Composition_EmptyProductionLikeRegistryIsUnavailable(ExecutionTargetKind kind) + { + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection([]); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.absent", kind))); + + Assert.Equal(TargetSelectionFailure.ProviderNotRegistered, exception.Failure); + Assert.Contains("not registered", exception.Message); + } + + [Theory] + [InlineData(ExecutionTargetKind.Simulation, ExecutionTargetKind.PhysicalHardware)] + [InlineData(ExecutionTargetKind.PhysicalHardware, ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.RecordedReplay, ExecutionTargetKind.PhysicalHardware)] + public void Composition_MismatchDoesNotSelectOtherProvider( + ExecutionTargetKind registeredKind, + ExecutionTargetKind requestedKind) + { + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection( + [ + new("synthetic.selected", registeredKind), + new("synthetic.other", requestedKind) + ]); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.selected", requestedKind))); + + Assert.Equal(TargetSelectionFailure.KindMismatch, exception.Failure); + Assert.Contains("no fallback", exception.Message); + } + + [Theory] + [InlineData(ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.PhysicalHardware)] + public void Composition_DuplicatesFailAtRegistrationBeforeContainerBuild(ExecutionTargetKind duplicateKind) + { + var services = new ServiceCollection(); + + var exception = Assert.Throws(() => services.AddAutoForgeTargetSelection( + [ + new("synthetic.provider", ExecutionTargetKind.Simulation), + new("SYNTHETIC.PROVIDER", duplicateKind) + ])); + + Assert.Equal(TargetSelectionFailure.DuplicateProviderIdentifier, exception.Failure); + Assert.Empty(services); + } + + [Fact] + public void Composition_CallerMutationBeforeContainerBuildCannotChangeRegistry() + { + var original = new ExecutionTargetDescriptor("synthetic.selected", ExecutionTargetKind.Simulation); + List registrations = [original]; + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection(registrations); + + registrations.Clear(); + registrations.Add(new("synthetic.selected", ExecutionTargetKind.PhysicalHardware)); + registrations.Add(new("SYNTHETIC.SELECTED", ExecutionTargetKind.RecordedReplay)); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + + Assert.Same(original, resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.selected", ExecutionTargetKind.Simulation))); + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.selected", ExecutionTargetKind.PhysicalHardware))); + Assert.Equal(TargetSelectionFailure.KindMismatch, exception.Failure); + } + + [Fact] + public void Composition_RejectsRepeatedSetupRatherThanSilentlyReplacingResolver() + { + var original = new ExecutionTargetDescriptor("synthetic.original", ExecutionTargetKind.Simulation); + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection([original]); + + var exception = Assert.Throws(() => services.AddAutoForgeTargetSelection([])); + + Assert.Contains("single registration call", exception.Message); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + Assert.Same(original, resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.original", ExecutionTargetKind.Simulation))); + } + + [Fact] + public void Composition_RejectsMissingSelectionThroughResolvedService() + { + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection([]); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + + var exception = Assert.Throws(() => resolver.Resolve(null!)); + + Assert.Equal("selection", exception.ParamName); + } + + [Theory] + [InlineData("")] + [InlineData(" \t")] + public void Composition_RejectsInvalidIdentifierAtSelectionBoundary(string identifier) + { + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection([]); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor(identifier, ExecutionTargetKind.Simulation))); + + Assert.Equal("providerIdentifier", exception.ParamName); + } + + [Fact] + public void Composition_RejectsUndefinedKindAtSelectionBoundary() + { + var services = new ServiceCollection(); + services.AddAutoForgeTargetSelection([]); + using var provider = services.BuildServiceProvider(); + var resolver = provider.GetRequiredService(); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.invalid", default))); + + Assert.Equal("kind", exception.ParamName); + } + + [Fact] + public void Composition_RejectsNullRegistrationsWithoutAddingServices() + { + var services = new ServiceCollection(); + + var exception = Assert.Throws(() => services.AddAutoForgeTargetSelection(null!)); + + Assert.Equal("registrations", exception.ParamName); + Assert.Empty(services); + } + + [Fact] + public void Composition_RejectsNullServiceCollection() + { + var exception = Assert.Throws(() => + ServiceCollectionExtensions.AddAutoForgeTargetSelection(null!, [])); + + Assert.Equal("services", exception.ParamName); + } +} diff --git a/src/tests/AutoForge.IntegrationTests/UiCompositionTests.cs b/src/tests/AutoForge.IntegrationTests/UiCompositionTests.cs new file mode 100644 index 0000000..c86e292 --- /dev/null +++ b/src/tests/AutoForge.IntegrationTests/UiCompositionTests.cs @@ -0,0 +1,189 @@ +using AutoForge.Application.ExecutionTargets; +using AutoForge.Core.ExecutionTargets; +using AutoForge.UI; +using AutoForge.UI.Features.ExecutionTargets.SelectExecutionTarget; +using Microsoft.AspNetCore.Components; +using Microsoft.AspNetCore.Components.Routing; +using Microsoft.AspNetCore.Components.Web; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; + +namespace AutoForge.IntegrationTests; + +public sealed class UiCompositionTests +{ + [Fact] + public async Task Routes_HomePageUsesReusableStatusNoticeAndExplainsCurrentScope() + { + using var provider = CreateProvider([], "http://localhost/"); + + var html = await RenderRoutesAsync(provider); + + Assert.Contains("

AutoForge foundation

", html); + Assert.Contains("Review execution-target selection", html); + Assert.Contains("status-notice--information", html); + Assert.Contains("Simulation, diagnostics and hardware operations are not implemented.", html); + Assert.Contains("Target selection is metadata only", html); + } + + [Fact] + public async Task Routes_SelectionPageResolvesSyntheticMetadataThroughRealApplicationService() + { + var expected = new ExecutionTargetDescriptor( + "synthetic.simulation", + ExecutionTargetKind.Simulation); + using var provider = CreateProvider([expected], "http://localhost/execution-targets"); + var selection = provider.GetRequiredService(); + selection.ProviderIdentifier = "SYNTHETIC.SIMULATION"; + selection.SelectedKind = ExecutionTargetKind.Simulation; + selection.Select(); + + var html = await RenderRoutesAsync(provider); + + Assert.Contains("Select execution-target metadata", html); + Assert.Contains("status-notice--success", html); + Assert.Contains("data-provider=\"synthetic.simulation\"", html); + Assert.Contains("data-kind=\"Simulation\"", html); + Assert.Contains("Resolved registered metadata for synthetic.simulation (Simulation)", html); + Assert.Contains("does not connect to a vehicle or authorize an operation", html); + Assert.DoesNotContain("connected", html, StringComparison.OrdinalIgnoreCase); + Assert.DoesNotContain("write-approved", html, StringComparison.OrdinalIgnoreCase); + Assert.Same(expected, selection.SelectedDescriptor); + } + + [Fact] + public async Task Routes_EmptyRegistryAndUnknownProviderRemainVisibleWithoutFallback() + { + using var provider = CreateProvider([], "http://localhost/execution-targets"); + var selection = provider.GetRequiredService(); + selection.ProviderIdentifier = "synthetic.absent"; + selection.SelectedKind = ExecutionTargetKind.PhysicalHardware; + selection.Select(); + + var html = await RenderRoutesAsync(provider); + + Assert.Contains("status-notice--error", html); + Assert.Contains("Provider 'synthetic.absent' is not registered.", html); + Assert.Null(selection.SelectedDescriptor); + Assert.Contains("does not connect to a vehicle, execute an operation or grant write approval", html); + } + + [Fact] + public async Task Routes_RejectsMissingOrInvalidExplicitInputsInRenderedState() + { + using var provider = CreateProvider( + [new ExecutionTargetDescriptor("synthetic.simulation", ExecutionTargetKind.Simulation)], + "http://localhost/execution-targets"); + var selection = provider.GetRequiredService(); + selection.ProviderIdentifier = " "; + selection.SelectedKind = ExecutionTargetKind.Simulation; + selection.Select(); + + var blankIdentifierHtml = await RenderRoutesAsync(provider); + Assert.Contains("Enter an explicit provider identifier.", blankIdentifierHtml); + Assert.Null(selection.SelectedDescriptor); + + selection.ProviderIdentifier = "synthetic.simulation"; + selection.SelectedKind = null; + selection.Select(); + + var missingKindHtml = await RenderRoutesAsync(provider); + Assert.Contains("Choose an explicit execution-target kind.", missingKindHtml); + Assert.Null(selection.SelectedDescriptor); + + selection.ProviderIdentifier = "synthetic.simulation "; + selection.SelectedKind = ExecutionTargetKind.Simulation; + selection.Select(); + + var invalidIdentifierHtml = await RenderRoutesAsync(provider); + Assert.Contains("status-notice--error", invalidIdentifierHtml); + Assert.Null(selection.SelectedDescriptor); + } + + [Fact] + public async Task Routes_RejectsProviderKindMismatchAndDoesNotFallback() + { + using var provider = CreateProvider( + [ + new ExecutionTargetDescriptor("synthetic.selected", ExecutionTargetKind.Simulation), + new ExecutionTargetDescriptor("synthetic.other", ExecutionTargetKind.PhysicalHardware) + ], + "http://localhost/execution-targets"); + var selection = provider.GetRequiredService(); + selection.ProviderIdentifier = "synthetic.selected"; + selection.SelectedKind = ExecutionTargetKind.PhysicalHardware; + selection.Select(); + + var html = await RenderRoutesAsync(provider); + + Assert.Contains("Provider 'synthetic.selected' is registered for Simulation", html); + Assert.Contains("not the requested PhysicalHardware", html); + Assert.Contains("no fallback is allowed", html); + Assert.DoesNotContain("data-provider=", html); + Assert.Null(selection.SelectedDescriptor); + } + + [Fact] + public async Task Routes_UnknownLocationShowsExplicitNotFoundPageAndNavigation() + { + using var provider = CreateProvider([], "http://localhost/not-a-route"); + + var html = await RenderRoutesAsync(provider); + + Assert.Contains("

Page not found

", html); + Assert.Contains("That AutoForge page does not exist.", html); + Assert.Contains("aria-label=\"Main navigation\"", html); + Assert.Contains("href=\"/execution-targets\"", html); + } + + private static ServiceProvider CreateProvider( + IEnumerable registrations, + string uri) + { + var services = new ServiceCollection(); + services.AddLogging(); + services.AddAutoForgeTargetSelection(registrations); + services.AddAutoForgeUi(); + services.AddSingleton(new TestNavigationManager(uri)); + services.AddSingleton(); + services.AddSingleton(); + return services.BuildServiceProvider(); + } + + private static async Task RenderRoutesAsync(IServiceProvider services) + { + await using var renderer = new HtmlRenderer( + services, + services.GetRequiredService()); + + return await renderer.Dispatcher.InvokeAsync(async () => + { + var component = await renderer.RenderComponentAsync(); + return component.ToHtmlString(); + }); + } + + private sealed class TestNavigationManager : NavigationManager + { + public TestNavigationManager(string uri) + { + Initialize("http://localhost/", uri); + } + + protected override void NavigateToCore(string uri, bool forceLoad) + { + Uri = ToAbsoluteUri(uri).ToString(); + NotifyLocationChanged(forceLoad); + } + } + + private sealed class TestNavigationInterception : INavigationInterception + { + public Task EnableNavigationInterceptionAsync() => Task.CompletedTask; + } + + private sealed class TestScrollToLocationHash : IScrollToLocationHash + { + public Task RefreshScrollPositionForHash(string locationAbsolute) => Task.CompletedTask; + } +} diff --git a/src/tests/AutoForge.UnitTests/AutoForge.UnitTests.csproj b/src/tests/AutoForge.UnitTests/AutoForge.UnitTests.csproj new file mode 100644 index 0000000..8d358b9 --- /dev/null +++ b/src/tests/AutoForge.UnitTests/AutoForge.UnitTests.csproj @@ -0,0 +1,29 @@ + + + + net10.0 + false + true + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/tests/AutoForge.UnitTests/ExecutionTargetDescriptorTests.cs b/src/tests/AutoForge.UnitTests/ExecutionTargetDescriptorTests.cs new file mode 100644 index 0000000..e0857df --- /dev/null +++ b/src/tests/AutoForge.UnitTests/ExecutionTargetDescriptorTests.cs @@ -0,0 +1,55 @@ +using AutoForge.Core.ExecutionTargets; + +namespace AutoForge.UnitTests; + +public sealed class ExecutionTargetDescriptorTests +{ + [Theory] + [InlineData(ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.RecordedReplay)] + [InlineData(ExecutionTargetKind.PhysicalHardware)] + public void Constructor_PreservesExplicitIdentifierAndKind(ExecutionTargetKind kind) + { + var descriptor = new ExecutionTargetDescriptor("Synthetic.Provider", kind); + + Assert.Equal("Synthetic.Provider", descriptor.ProviderIdentifier); + Assert.Equal(kind, descriptor.Kind); + } + + [Fact] + public void Constructor_RejectsNullIdentifier() + { + var exception = Assert.Throws( + () => new ExecutionTargetDescriptor(null!, ExecutionTargetKind.Simulation)); + + Assert.Equal("providerIdentifier", exception.ParamName); + } + + [Theory] + [InlineData("")] + [InlineData(" ")] + [InlineData("\t\r\n")] + [InlineData(" synthetic.simulation")] + [InlineData("synthetic.simulation ")] + public void Constructor_RejectsBlankOrPaddedIdentifier(string identifier) + { + var exception = Assert.Throws( + () => new ExecutionTargetDescriptor(identifier, ExecutionTargetKind.Simulation)); + + Assert.Equal("providerIdentifier", exception.ParamName); + } + + [Theory] + [InlineData(-1)] + [InlineData(0)] + [InlineData(4)] + [InlineData(int.MaxValue)] + public void Constructor_RejectsUndefinedKind(int kind) + { + var exception = Assert.Throws( + () => new ExecutionTargetDescriptor("synthetic.provider", (ExecutionTargetKind)kind)); + + Assert.Equal("kind", exception.ParamName); + Assert.Contains("defined execution-target kind", exception.Message); + } +} diff --git a/src/tests/AutoForge.UnitTests/ExecutionTargetResolverTests.cs b/src/tests/AutoForge.UnitTests/ExecutionTargetResolverTests.cs new file mode 100644 index 0000000..b51eb72 --- /dev/null +++ b/src/tests/AutoForge.UnitTests/ExecutionTargetResolverTests.cs @@ -0,0 +1,168 @@ +using AutoForge.Application.ExecutionTargets; +using AutoForge.Core.ExecutionTargets; + +namespace AutoForge.UnitTests; + +public sealed class ExecutionTargetResolverTests +{ + [Theory] + [InlineData(ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.RecordedReplay)] + [InlineData(ExecutionTargetKind.PhysicalHardware)] + public void Resolve_ReturnsExactRegisteredDescriptor(ExecutionTargetKind kind) + { + var registered = new ExecutionTargetDescriptor("synthetic.provider", kind); + var resolver = new ExecutionTargetResolver([registered]); + + var result = resolver.Resolve(new ExecutionTargetDescriptor("synthetic.provider", kind)); + + Assert.Same(registered, result); + Assert.Equal(kind, result.Kind); + } + + [Fact] + public void Resolve_UsesOrdinalCaseInsensitiveIdentifiers() + { + var registered = new ExecutionTargetDescriptor("SYNTHETIC.provider", ExecutionTargetKind.Simulation); + var resolver = new ExecutionTargetResolver([registered]); + + var result = resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.PROVIDER", ExecutionTargetKind.Simulation)); + + Assert.Same(registered, result); + Assert.Equal("SYNTHETIC.provider", result.ProviderIdentifier); + } + + [Fact] + public void Resolve_DoesNotUseCultureSensitiveIdentifierComparison() + { + var registered = new ExecutionTargetDescriptor("synthetic.file", ExecutionTargetKind.Simulation); + var resolver = new ExecutionTargetResolver([registered]); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.f\u0131le", ExecutionTargetKind.Simulation))); + + Assert.Equal(TargetSelectionFailure.ProviderNotRegistered, exception.Failure); + } + + [Fact] + public void Resolve_RejectsMissingSelection() + { + var resolver = new ExecutionTargetResolver([]); + + var exception = Assert.Throws(() => resolver.Resolve(null!)); + + Assert.Equal("selection", exception.ParamName); + } + + [Theory] + [InlineData(ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.RecordedReplay)] + [InlineData(ExecutionTargetKind.PhysicalHardware)] + public void Resolve_EmptyRegistryReportsNotRegistered(ExecutionTargetKind kind) + { + var resolver = new ExecutionTargetResolver([]); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.absent", kind))); + + Assert.Equal(TargetSelectionFailure.ProviderNotRegistered, exception.Failure); + Assert.Contains("synthetic.absent", exception.Message); + Assert.Contains("not registered", exception.Message); + } + + [Fact] + public void Resolve_UnknownIdentifierDoesNotSelectAnotherProviderOfSameKind() + { + var resolver = new ExecutionTargetResolver( + [new ExecutionTargetDescriptor("synthetic.registered", ExecutionTargetKind.Simulation)]); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.unknown", ExecutionTargetKind.Simulation))); + + Assert.Equal(TargetSelectionFailure.ProviderNotRegistered, exception.Failure); + } + + [Theory] + [InlineData(ExecutionTargetKind.Simulation, ExecutionTargetKind.RecordedReplay)] + [InlineData(ExecutionTargetKind.Simulation, ExecutionTargetKind.PhysicalHardware)] + [InlineData(ExecutionTargetKind.RecordedReplay, ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.RecordedReplay, ExecutionTargetKind.PhysicalHardware)] + [InlineData(ExecutionTargetKind.PhysicalHardware, ExecutionTargetKind.Simulation)] + [InlineData(ExecutionTargetKind.PhysicalHardware, ExecutionTargetKind.RecordedReplay)] + public void Resolve_RejectsEveryKindMismatchWithoutFallback( + ExecutionTargetKind registeredKind, + ExecutionTargetKind requestedKind) + { + var resolver = new ExecutionTargetResolver( + [ + new ExecutionTargetDescriptor("synthetic.selected", registeredKind), + new ExecutionTargetDescriptor("synthetic.other", requestedKind) + ]); + + var exception = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.selected", requestedKind))); + + Assert.Equal(TargetSelectionFailure.KindMismatch, exception.Failure); + Assert.Contains(registeredKind.ToString(), exception.Message); + Assert.Contains(requestedKind.ToString(), exception.Message); + Assert.Contains("no fallback", exception.Message); + } + + [Theory] + [InlineData("synthetic.provider", ExecutionTargetKind.Simulation)] + [InlineData("SYNTHETIC.PROVIDER", ExecutionTargetKind.Simulation)] + [InlineData("Synthetic.Provider", ExecutionTargetKind.PhysicalHardware)] + public void Constructor_RejectsDuplicateIdentifiersRegardlessOfKind( + string duplicateIdentifier, + ExecutionTargetKind duplicateKind) + { + var exception = Assert.Throws(() => new ExecutionTargetResolver( + [ + new ExecutionTargetDescriptor("synthetic.provider", ExecutionTargetKind.Simulation), + new ExecutionTargetDescriptor(duplicateIdentifier, duplicateKind) + ])); + + Assert.Equal(TargetSelectionFailure.DuplicateProviderIdentifier, exception.Failure); + Assert.Contains("unique identifiers", exception.Message); + } + + [Fact] + public void Constructor_SnapshotsCallerCollection() + { + var original = new ExecutionTargetDescriptor("synthetic.original", ExecutionTargetKind.Simulation); + var replacement = new ExecutionTargetDescriptor("synthetic.original", ExecutionTargetKind.PhysicalHardware); + List registrations = [original]; + var resolver = new ExecutionTargetResolver(registrations); + + registrations.Clear(); + registrations.Add(replacement); + registrations.Add(replacement); + registrations.Add(new ExecutionTargetDescriptor("synthetic.later", ExecutionTargetKind.RecordedReplay)); + + Assert.Same(original, resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.original", ExecutionTargetKind.Simulation))); + var mismatch = Assert.Throws(() => resolver.Resolve(replacement)); + Assert.Equal(TargetSelectionFailure.KindMismatch, mismatch.Failure); + var unknown = Assert.Throws(() => resolver.Resolve( + new ExecutionTargetDescriptor("synthetic.later", ExecutionTargetKind.RecordedReplay))); + Assert.Equal(TargetSelectionFailure.ProviderNotRegistered, unknown.Failure); + } + + [Fact] + public void Constructor_RejectsNullRegistrations() + { + var exception = Assert.Throws(() => new ExecutionTargetResolver(null!)); + + Assert.Equal("registrations", exception.ParamName); + } + + [Fact] + public void Constructor_RejectsNullDescriptor() + { + var exception = Assert.Throws(() => new ExecutionTargetResolver([null!])); + + Assert.Equal("registrations", exception.ParamName); + Assert.Contains("null descriptors", exception.Message); + } +} diff --git a/src/tests/AutoForge.UnitTests/StatusNoticeRenderingTests.cs b/src/tests/AutoForge.UnitTests/StatusNoticeRenderingTests.cs new file mode 100644 index 0000000..0a4b2bf --- /dev/null +++ b/src/tests/AutoForge.UnitTests/StatusNoticeRenderingTests.cs @@ -0,0 +1,45 @@ +using AutoForge.Components; +using Microsoft.AspNetCore.Components; +using Microsoft.AspNetCore.Components.Web; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; + +namespace AutoForge.UnitTests; + +public sealed class StatusNoticeRenderingTests +{ + [Theory] + [InlineData(StatusNoticeTone.Information, "information")] + [InlineData(StatusNoticeTone.Success, "success")] + [InlineData(StatusNoticeTone.Warning, "warning")] + [InlineData(StatusNoticeTone.Error, "error")] + public async Task Render_ExposesToneAndEncodesUntrustedMessage( + StatusNoticeTone tone, + string expectedTone) + { + var services = new ServiceCollection().AddLogging(); + using var provider = services.BuildServiceProvider(); + await using var renderer = new HtmlRenderer( + provider, + provider.GetRequiredService()); + + var html = await renderer.Dispatcher.InvokeAsync(async () => + { + var component = await renderer.RenderComponentAsync( + ParameterView.FromDictionary(new Dictionary + { + [nameof(StatusNotice.Message)] = "Provider & unavailable", + [nameof(StatusNotice.Tone)] = tone + })); + + return component.ToHtmlString(); + }); + + Assert.Contains("role=\"status\"", html); + Assert.Contains("aria-live=\"polite\"", html); + Assert.Contains($"data-tone=\"{expectedTone}\"", html); + Assert.Contains($"status-notice--{expectedTone}", html); + Assert.Contains("Provider <script>alert('unsafe')</script> & unavailable", html); + Assert.DoesNotContain("