AutoForge/prompts/ROADMAP.md

39 KiB

AutoForge development roadmap

Status and authority

  • Initialized: 2026-10-28.
  • Current phase: corrected profile milestone accepted; simulated diagnostic communication next.
  • Active assignment: Step-03, ready for manual worker execution.
  • Last accepted milestone: Step-02 with Step-02A, accepted 2026-10-28.
  • Outstanding corrections: none.
  • Step-03 status: READY FOR WORKER; no implementation or report yet.
  • Current state and handoff: STATE.md.
  • 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.

Product goals

Build one extensible, local-first .NET 10 platform combining:

  1. Deterministic vehicle simulation and virtual electronic control modules.
  2. Diagnostics, telemetry, visualization, calibration management, and eventually explicitly authorized module-specific programming.
  3. Local AI planning and vehicle knowledge with independently validated runbooks.

Support arbitrary vehicle module inventories, not a fixed ECU/TCU list. Vehicle, module, protocol, and calibration definitions must be data-driven and applicable to specific hardware/software identities. Unknown or restricted capabilities must remain explicit. Simulation, manual diagnostics, manual calibration work, and tests must function without an AI service or cloud account.

Preserve the complete product vision through incremental, integrated vertical slices. Do not finish one major subsystem in isolation before integrating it.

Repository and manual workflow

The only top-level project directories are docs, src, and prompts. Necessary root configuration files are allowed. Preserve Git metadata and existing protected repository infrastructure; these are not project directories.

  • All application projects and automated test projects belong under src.
  • The primary solution will be src/AutoForge.slnx.
  • Tests belong under src/tests, never a top-level tests directory.
  • Generated test evidence, if retained, belongs in an ignored location under src, not a top-level artifacts directory.
  • Technical/product documentation belongs under docs.
  • All file-based orchestrator/worker communication belongs under prompts.
  • Do not create a nested AutoForge repository directory.
  • Do not initialize a repository, automatically commit, or push.
  • .github/copilot-instructions.md, if present, is read-only. If absent, do not create it or an alternative intended to override it.

The orchestrator writes assignments and maintains this roadmap and state. The worker alone writes application code, tests, technical documentation, and the root README; executes builds/tests; and writes the corresponding report. The orchestrator reviews the assignment, report, relevant source and tests, Git changes, documentation, and actual reported command evidence. It does not execute application builds/tests or implement fixes.

Handoffs are manual. No agent invocation, messaging automation, polling, watchers, automatic prompt pickup, or unattended progression is permitted.

Assignments use Step-01.md, Step-02.md, etc. Reports use Step-01-Report.md, Step-02-Report.md, etc. Corrective assignments use the original number plus sequential uppercase letters, for example Step-01A.md and Step-01A-Report.md, then Step-01B.md. Accept all necessary corrections before assigning the next major step. Do not use the superseded numeric-dot prompt/report naming convention.

Architecture baseline

Existing accepted foundation, preserved

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 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

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.

Step-02 has added Core vehicle/profile models, an Application Features/Vehicles/Profiles import/catalog/select/export feature and the existing UI's /vehicle-profiles page. Step-02A closed the timestamp and optional evidence constraint gaps; the corrected Step-02 milestone is accepted. Worker verification now covers 103 unit and 37 integration cases (140 total).

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 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 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 platform boundary justifies extraction. Avoid premature microservices.

For Step-03, two concrete boundaries are now justified by actual implementation: AutoForge.Diagnostics owns diagnostic/provider/transport contracts, a clearly synthetic protocol and decoding; AutoForge.Simulation implements virtual modules and simulated transport against those contracts. Application coordinates Diagnostics, not Simulation internals. Client composes Simulation in-process. Simulation depends on Core/Diagnostics, never Application/UI/Client or an LLM. These are assigned additions, not existing projects; the current solution still contains seven projects until the worker implements the step.

Planned dependency flow:

flowchart TD
    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]
    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. 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

  1. Explicit target: simulation, recorded replay, and physical hardware are distinct execution targets. Never infer, silently switch, or fall back between them. Descriptor selection is not a connection or a successful operation.
  2. Layered diagnostics: separate physical transport, vehicle network, addressing, diagnostic protocol/services, decoding, calibration operations, and application commands. Generic OBD-II does not imply access to all modules.
  3. Determinism: fixed virtual time and reproducible inputs/seeds drive simulation. Do not use wall-clock timing, rendering frequency, or LLM sensor generation as the physics source. Timeouts/faults must be reproducible.
  4. Physical consistency: RPM, gear ratio, speed, torque/load, fuel use, and temperatures derive from coupled state within documented model assumptions. Simplified predictions must not be marketed as validated real-world results.
  5. Independent oracle: tests may inspect simulation ground truth through an isolated test boundary; application and AI paths may not bypass diagnostics to access it.
  6. Truthful data: distinguish vehicle configuration, firmware, calibration, calibration definitions, diagnostic captures, and telemetry recordings. Version persisted schemas; preserve originals and applicability information.
  7. Telemetry lineage: preserve source/module identity, units, sampling, data quality, raw/decoded/derived/estimated/simulated classification, and both simulation and capture time as applicable.
  8. Separate operations: live simulation, recorded-session replay, and deterministic scenario re-execution are not interchangeable. Comparisons identify source, configuration, scenario, confidence, and limitations.
  9. Safe execution: AI proposes versioned logical runbooks. A deterministic validator/executor checks identity, applicability, limits, dependencies, approvals, preconditions, backup, readback, unrelated-data preservation, diagnostics, and supported recovery.
  10. Three verifications: backup verification, programming verification, and functional verification are distinct. Missing, interrupted, or uncertain verification cannot be reported as success.
  11. Evidence and authority: VERIFIED, UNVERIFIED, INFERRED, and SYNTHETIC information retain sources, applicability, confidence, verification status, and limitations. Similarity search is not authority for offsets or exact compatibility. Unknown calibration locations remain unknown.
  12. Physical gates: first hardware integration is read-only. Capability discovery, transport selection, simulation approval, or an AI recommendation never authorizes physical writes. Physical programming requires separate explicit authorization and module-specific controlled evidence.
  13. Prohibited functionality: no emissions defeat, anti-theft bypass, mileage falsification, safety-system disabling, or unrestricted safety-critical writes.
  14. Local-first and replaceable AI: allow local OpenAI-compatible endpoints, initially considering LM Studio and Qwen3.5-9B around a practical 16 GB model memory budget. Verify actual availability, licensing, context, and memory use at implementation time; do not make a model or fine-tuning a core dependency.
  15. Honest errors and support: no fake providers, silent defaults, fabricated manufacturer protocol behavior, fabricated backups, or unverified platform claims. Protect vehicle identifiers, recordings, model assets, and local service endpoints. Never commit secrets or private runtime datasets.

Milestones and acceptance gates

Step-01, Step-01A and corrected Step-02/Step-02A are accepted. The original 93-case Step-02 run is retained as historical evidence; the correction adds actual before/after regressions and a 140-case passing run. Step-03 is the only active assignment. Step-03 and later 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 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 ACCEPTED 2026-10-28 AFTER 02A Immutable versioned profile metadata, strict interchange, provenance/capabilities, exact selection and real UI; correction evidence inspected
02A Profile timestamp and optional evidence validation correction 02 review findings ACCEPTED 2026-10-28 Explicit-offset parser and optional-constraint semantics inspected; actual pre-fix failures and 103 unit/37 integration passes plus native checks reported
03 Virtual modules and diagnostic communication 02 and 02A accepted READY FOR WORKER Explicit simulated session, wire-path module discovery/identity, synthetic DTC/read-clear and static telemetry, trace and deterministic negative/timeout/cancellation evidence
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 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
09 Comparative evaluation and complete synthetic demonstration 08 PLANNED Complete demonstration below plus deterministic fault/regression matrix and independent verification of intended and unintended changes
10 Verified OBDX Pro GT read-only integration 09 plus documented device research/access PLANNED / HARDWARE GATE Source-backed device support matrix, explicit physical target, real read-only identification/diagnostics/telemetry recording where supported; no write path
11 Advanced dashboards, analysis, and comparisons 09; 10 for real captures PLANNED Persist configurable layouts/thresholds/units, linked charts, raw-data inspection, multi-run/multi-vehicle comparisons with lineage and uncertainty
12 Broader diagnostic protocols and hardware adapters 10 PLANNED Conformance-backed additional CAN/ISO-TP/UDS/KWP2000/J2534 or legacy adapters where verified; same application ports and capability restrictions
13 Curated vehicle knowledge and research workflow 08; 12 where needed PLANNED Sourced profile/module/calibration knowledge, review/promotion workflow, exact applicability, licensing/access controls; research cannot authorize writes
14 Higher-fidelity simulation and virtual module coverage 09; 13 for verified datasets PLANNED Validated model extensions, richer transmissions/environment/module interactions and reproducible fault coverage; published fidelity limits
15 AI evaluation and optional specialization 08, 09, 13 and adequate datasets PLANNED Held-out deterministic runbook evaluations, refusal/uncertainty cases, memory/latency measurements; LoRA/QLoRA only if justified by measured benefit
16 Programming qualification without physical writes 07, 09, 10, applicable 12/13 evidence PLANNED Module-specific safety case, bench plan, voltage/state/identity checks, interruption/recovery tests in simulation, legal authorization and defined go/no-go criteria
17 Explicitly authorized controlled bench programming 16 and separate user authorization PLANNED / AUTHORIZATION GATE Authorized supported bench target only; verified backup completeness, transfer/readback/recovery evidence and audit; no general vehicle-write enablement
18 Approved vehicle/module-specific programming 17 and separate vehicle-operation authorization PLANNED / AUTHORIZATION GATE Explicit per-operation approvals, compatibility/operating-state/power/security checks and proven recovery limits; strict module-specific support matrix
19 Packaging, extensibility, and additional platforms 05, 09; feature-specific gates remain PLANNED Offline-friendly reproducible releases, documented supported hosts, feature manifests/DI, compatibility/migration regression evidence
20 Optional MCP and firmware-emulation research 08, 13; isolated research approvals OPTIONAL / PLANNED Concrete benefit and separate ADR; restricted tools retain validator/approval boundary; emulation limitations and proprietary-data rights documented

Scope details for Steps 02-10

  • 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 capture contains a complete firmware image.
  • 02A accepted correction: strict full-date/time/offset parsing, optional module evidence constraints, atomic import/UI regressions and aligned docs. Original reports remain unchanged; acceptance uses the corrected implementation.
  • 03: synthetic module state/storage, identification, telemetry definitions, DTC retrieval and simulated clearing, request/response semantics, addressing, session state where appropriate, delays, invalid requests, unsupported services, interruption and negative responses. Authentic protocol semantics require sources; use an explicitly synthetic versioned protocol first rather than inventing manufacturer behavior. Keep the existing profile schema intact; separate validated simulation endpoint/service definitions from profile metadata. A real Simulation provider is registered explicitly; update former empty-provider UI wording. No physical adapter or vehicle dynamics is implemented in this step.
  • 04: start/stop/pause/resume/reset/step, configurable pacing independent of simulation results, save/load configuration, seeded scenarios, engine idle, 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: 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 visible gauges. Mark captured versus interpolated/reconstructed samples.
  • 07: scalar/table definitions with ranges/scaling/units and dependencies; original/proposed/tested/approved versions, structured diffs, verified backup completeness, approval binding, audit, readback, unrelated-data preservation, restoration where supported, explicit failure/recovery outcomes.
  • 08: local inference provider configuration, structured queries plus optional semantic retrieval, source-backed applicability checks, versioned runbook schema and restricted tools. Include natural-language diagnostics, driving scenarios, and calibration planning; AI cannot emit arbitrary hardware frames/offset writes. Missing knowledge and disconnected inference produce explicit outcomes without disabling non-AI functionality.
  • 09: equivalent baseline/modified scenarios and initial state, independent calibration oracle, behavioral/fuel/shift comparisons with confidence labels, fault reports, replay/raw-trace inspection and an auditable verification report. Include timeout, unsupported service, malformed response, wrong identity/version, interruption, corruption/checksum, partial write, reset, incompatible config, DTC and failed-verification cases.
  • 10: verify OBDX Pro GT protocols, drivers, OS/architecture constraints, manufacturer libraries/SDKs, actual J2534 support and C# integration using attributable sources before implementation. Missing device/driver access means real-hardware verification is blocked, not passed by mocks. Restrict services to verified read-only allowlists; diagnostic access does not imply every module is discoverable or programmable.

Longer-term scope preservation

Steps 11-20 retain richer gauges/clusters/charts and dashboard editing, comparison 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. 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.

Bench and vehicle programming milestones may not proceed on roadmap status alone. If authorization, applicable definitions, safe test equipment, licensing, recovery evidence, or manufacturer procedures are missing, retain a blocked gate and continue only independent safe work through an explicit new assignment.

Required synthetic end-to-end demonstration

Target acceptance: Step-09. Use the explicitly synthetic AutoForge test truck, initial warm idle 650 RPM and proposed warm idle 1,250 RPM. These values and any memory layout are synthetic, not manufacturer calibration data.

  1. Load the synthetic vehicle; inspect its modules and current calibration.
  2. Start simulation; display original idle telemetry; record and stop the run.
  3. Request the idle change in natural language. The local AI identifies the applicable module/parameter and produces a versioned logical runbook.
  4. Deterministically validate identity, definition, range/dependencies, execution target and approval; back up the original virtual calibration and verify it.
  5. Apply only the approved simulated change. Verify the operation, read calibration back, confirm the target value and independently confirm unrelated values.
  6. Re-run the same scenario/initial state using the modified calibration; observe the changed idle behavior and record the second run.
  7. Replay either recording; compare both runs, preserving their source, time, configuration, fidelity, and confidence metadata.
  8. Inspect underlying diagnostic communications and a report separating backup, programming, and functional verification with supported recovery limitations.

Evidence must cover all these actions without privileged application/AI access to the test oracle. Add a table-based shift-schedule case later; do not imply all calibration requests are scalar edits. Simulation fuel-use changes are estimates, not proven real-world economy improvements.

Test and evidence strategy

  • Worker selects maintained .NET 10-compatible test packages after inspecting the installed SDK and package compatibility. No speculative SDK/package signatures.
  • Unit tests cover invariants, validation, decoding, algorithms, and failure semantics. Integration tests exercise real composition across boundaries, serialization/persistence, transports, and execution as those features arrive.
  • Add simulation-specific test projects only when they have real responsibilities. Keep all tests in src/tests and separate privileged oracle access.
  • Use deterministic fixtures/seeds/virtual time; define reproducibility and numeric tolerance contracts. Keep test infrastructure independent of AI/cloud/hardware.
  • Adapter contract and hardware tests distinguish stub evidence from real devices. AI evaluations include held-out invalid/unsupported/uncertain requests and deterministic validators, not only LLM-as-judge.
  • Record exact commands, target framework/platform, configuration, exit outcomes, test counts and failures, and durable evidence references in each worker report.
  • Run the smallest relevant builds/tests plus required regression coverage. 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

Initial decisions

  • 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 (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 for AI-assisted calibration execution and physical integration.
  • D-006: local-first replaceable inference; no initial fine-tuning/vector/MCP/cloud dependency. Storage implementations are chosen when real use cases arrive.
  • 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.
  • D-013: profile timestamps must contain their full date/time and explicit offset, never ambient date/time-zone defaults. A null optional module applicability identity is an absent constraint, not a requirement that the target identity also be null; supplied constraints remain validated and grant no authority.
  • D-014: Step-03 introduces Diagnostics and Simulation as purposeful separate libraries, composed by the existing Client. Diagnostic application features use provider-neutral ports; virtual state/oracles do not leak into Application/UI. Initial telemetry is explicitly static synthetic module state, not vehicle physics.

The worker records the relevant accepted decisions as technical ADRs when creating or changing the implementation. Future changes require a reason and roadmap/state history, not repeated redesign without evidence.

Completed

  • 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 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.
  • 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.
  • Reviewed the completed Step-02: immutable Core metadata, strict object/schema parsing, profile catalog/DI, UI, fixtures, new tests, Git changes and documentation. Worker evidence reports 59 unit + 34 integration cases passed, zero failed/skipped, zero-warning/error solution/native builds and actual profile UI smoke.
  • Source counts, restored assets, Release outputs and fixture shape corroborate those reported checks, not independent runtime execution. Static review found two untested validation defects; Step-02 was not accepted at that initial review.
  • Prepared Step-02A. Original Step-02 assignment/report remain unchanged; the worker was required to correct and report before a Step-03 handoff.
  • Reviewed and accepted Step-02A and corrected Step-02: strict timestamp lexical/ calendar/offset checks, null-as-absent evidence constraints, retained mismatch/ unknown-target failures, actual direct/codec/DI/UI regressions and documentation.
  • Reviewed worker-reported pre-fix failures, corrected focused runs, sequential zero-warning/error complete Release build, 103 unit + 37 integration passes, zero failed/skipped and native positive/error/original-fixture smoke. Source case counts, seven-project graph and existing outputs corroborate the report. The orchestrator did not run builds/tests or launch the native app.
  • Prepared Step-03 for manual handoff; no Step-02B is required.

Remaining

  • Worker execution of Step-03, then manual review and any Step-03A corrections before Step-04. Full vehicle dynamics and live dashboard milestones remain later.
  • Profile/module metadata is accepted. Virtual-module communication and later product capabilities remain planned. Preserve the complete sequence and safety gates rather than restarting or reducing scope.

Known blockers and uncertainties

No blocking profile-correction deficiency remains. The original Step-02 findings below are historical and resolved by accepted Step-02A:

  • R-01 originally used permissive DateTimeOffset parsing. The replacement requires complete date/time/seconds and explicit Z/numeric offset, validates its calendar and offset and preserves exporter precision without ambient defaults.
  • R-02 originally required both evidence and target identities null. The corrected helper treats an absent constraint as absent, while every supplied constraint still requires a matching known target identity.

The worker supplied actual pre-fix failures and post-fix unit/DI/UI/native evidence. Neither before/after input case was executed by the orchestrator.

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.
  • Step-02 resolved the working README CRLF issue: inspection found 149 LF and zero CRLF lines. A command-local CR-at-EOL-aware diff check passes. No global Git setting was changed; the existing LF-to-CRLF notice remains non-blocking.
  • Current README/schema/ADR text must be aligned with the corrective status and acceptance lifecycle by Step-03's worker while preserving the original 93-case and corrective 140-case reports. The corrected contracts are already documented.

No major environment installation, update, repair or rollback is automatically authorized. Physical definitions/access and programming approval remain future gates.