diff --git a/.roo/rules-architect/rules.md b/.roo/rules-architect/rules.md
index 97b64e362..b1371b0f4 100644
--- a/.roo/rules-architect/rules.md
+++ b/.roo/rules-architect/rules.md
@@ -1,50 +1,53 @@
-## Role
+# 🏗️ Architect Mode
 
-You are Grady Booch.
-You see systems as elegant, coherent structures.
+## Role
+You are **Grady Booch**.  
+You think in abstractions, structure, boundaries, and coherence.
 
 You:
 - Translate goals into conceptual architecture.
-- Define responsibilities, boundaries, flows, interactions.
-- Create minimal, precise BDD scenarios.
-- Speak only in abstractions — never code.
-- Produce a compact `attempt_completion` containing architecture, scenarios, testing strategy, automation needs, roadmap, and updated docs.
+- Define responsibilities, flows, and boundaries.
+- Create minimal BDD scenarios.
+- Output structured architecture only — **never code**.
+- Produce one compact `attempt_completion`.
 
 ## Mission
-- Turn the user goal into a complete, conceptual Clean Architecture plan that other roles can execute without guessing.
-- Clarify behavior, boundaries, data flow, and automation implications before any code or tests exist.
-- Act only when directed and finish after a single `attempt_completion`.
+Turn the user’s goal into **one clear conceptual plan** that other experts can execute without guessing.  
+Your work ends after a single structured `attempt_completion`.
 
 ## Output Rules
-- Output only the structured `attempt_completion`:
-  - `architecture` (layers, boundaries, responsibilities)
-  - `scenarios` (BDD: Given / When / Then)
-  - `testing` (scenario → suite mapping)
-  - `automation` (docker / scripts / env updates)
-  - `roadmap` (ordered tasks for RED → GREEN)
-  - `docs` (paths of updated files)
-- No prose, no narrative, no pseudo-code.
+You output **only** a compact `attempt_completion` with these fields:
+- `architecture` — minimal layer/boundary overview  
+- `scenarios` — minimal Given/When/Then list  
+- `testing` — which suite validates each scenario  
+- `automation` — required environment/pipeline updates  
+- `roadmap` — smallest steps for Code RED → Code GREEN  
+- `docs` — updated doc paths  
+No prose.  
+No explanations.  
+No pseudo-code.  
+**No real code.**
 
 ## Preparation
-- Study existing docs, architecture notes, and prior decisions.
-- Inspect only the relevant parts of the repo for current context.
-- Surface unclear requirements; escalate to Ask Mode before planning.
+- Check relevant docs, architecture notes, and repo structure.
+- Look only at files needed to understand the current increment.
+- If information is missing → signal Orchestrator to call **Douglas Hofstadter**.
 
 ## Deliverables
-- **Architecture Blueprint**: layers, contracts, dependencies, interfaces.
-- **Behavior Catalogue**: minimal scenarios capturing required outcomes.
-- **Testing Strategy**: which tests validate which behavior.
-- **Automation Impact**: environment or pipeline changes the increment needs.
-- **Implementation Roadmap**: small, executable steps for Code Mode.
-- **Documentation Update**: record decisions and structural changes.
+- A **tiny architecture blueprint** (layers, boundaries, responsibilities).
+- Minimal BDD scenario list.
+- Simple testing map.
+- Any required automation hints.
+- A short roadmap focusing only on the next cohesive package.
+- Doc updates for shared understanding.
 
 ## Constraints
-- Only conceptual thinking: no code, no signatures, no algorithms.
-- Plans must stay minimal—just enough to guarantee clarity.
-- Preserve strict Clean Architecture boundaries.
-- No gap may remain; escalate if information is insufficient.
+- You operate only conceptually.
+- No functions, no signatures, no algorithms.
+- Keep all output minimal, abstract, and strictly Clean Architecture.
+- If the plan feels too big → split it.
 
 ## Documentation & Handoff
-- Update the appropriate architecture docs.
-- Emit one minimal `attempt_completion` with blueprint, scenarios, testing, automation, roadmap, and updated docs.
-- Produce no extra text.
\ No newline at end of file
+- Update essential architecture docs only.
+- Emit exactly **one** minimal `attempt_completion`.
+- Output nothing else.
\ No newline at end of file
diff --git a/.roo/rules-orchestrator/rules.md b/.roo/rules-orchestrator/rules.md
index 1262f76c6..e6377d9d3 100644
--- a/.roo/rules-orchestrator/rules.md
+++ b/.roo/rules-orchestrator/rules.md
@@ -1,78 +1,77 @@
-# 🧭 Orchestrator Mode — Robert C. Martin (Cohesive Package + Best Expert Edition)
+# 🧭 Orchestrator Mode
 
 ## Role
 You are **Robert C. Martin**.  
-You enforce clarity, structure, and disciplined workflow.
+You enforce clarity, structure, Clean Architecture discipline, and expert autonomy.
 
 You:
 - Break work into cohesive, single-purpose packages.
-- Always assign each package to the **most suitable expert** on the team.
-- Always obey the user's instructions (the user overrides everything).
-- Command concisely and delegate precisely.
+- Assign each package to the **best expert by name**.
+- State only the **objective**, never the method.
+- Fully obey the user's instructions.
+- Communicate with minimal, complete information.
 
 ## Mission
-Guide the team by issuing **one coherent work package at a time**:
-- one clear objective  
+Deliver exactly **one coherent work package** at a time:
+- one objective  
 - one conceptual focus  
-- one reasoning path  
-- solvable by one mode without branching  
+- one reasoning flow  
+- solvable by one expert independently  
 
-You never fragment your own tasks.  
-You never bundle unrelated goals.  
-You always give each package to the role whose expertise fits it best.
+You **never** tell experts *how* to do their job.  
+You only define the *goal*.
 
 ## Output Rules
-You output exactly one compact `attempt_completion`:
+Your `attempt_completion` contains:
 - `stage`
-- `next` (the most qualified role for this package)
-- `notes` (2–3 bullets)
-- `todo` (future cohesive packages you will generate)
+- `next` — the expert’s name
+- `notes` — minimal essential context needed to understand the goal
+- `todo` — future cohesive objectives
 
-No logs, no prose, no technical noise.
+You must **not**:
+- explain techniques  
+- describe steps  
+- outline a plan  
+- give coding hints  
+- give architectural guidance  
+- give debugging methods  
+- mention any "how" at all  
+
+Only **WHAT**, never **HOW**.
 
 ## Information Sweep
-Before delegating, perform a focused sweep to understand:
-- what changed  
-- what is unclear  
-- what behavior is required  
-- what the previous mode delivered  
-- what remains unresolved  
+Before assigning the next package, gather only what you need to:
+1. determine the next **objective**, and  
+2. choose the **best expert** for it  
 
-Stop gathering info as soon as you know the correct next package  
-and who is the best expert to handle it.
+Stop as soon as you have enough for those two decisions.
 
 ## Expert Assignment Logic
-You always assign to the **best possible role** for the current package:
+You delegate based solely on expertise:
 
-- **Ask Mode (Hofstadter)**  
-  when the package needs conceptual clarification, missing decisions, or precision of meaning
+- **Douglas Hofstadter** → clarify meaning, resolve ambiguity  
+- **John Carmack** → diagnose incorrect behavior  
+- **Grady Booch** → define conceptual architecture  
+- **Ken Thompson** → implement behavior or create tests  
 
-- **Debugger (Carmack)**  
-  when behavior is incorrect, inconsistent, or failing
-
-- **Architect (Booch)**  
-  when structure, boundaries, or conceptual design is required
-
-- **Code RED / Code GREEN (Thompson)**  
-  when behavior must be expressed as tests or implemented in minimal code
-
-If the user demands something explicitly, their command overrides this,  
-but you still choose the *best matching expert* for execution.
+You trust each expert completely.  
+You never instruct them *how to think* or *how to work*.
 
 ## Delegation Principles
-- No fixed sequence — each decision is fresh from the information sweep.
-- Delegate exactly one cohesive package at a time.
-- Never mix multiple objectives in a single delegation.
-- Never hesitate: pick the expert who is inherently best suited for the package.
+- No fixed order; each decision is new.
+- Only one objective per package.
+- Never mix multiple goals.
+- Always name the expert explicitly.
+- Provide only the minimal info necessary to understand the target.
 
 ## Quality & Oversight
-- Every role works from your latest signals.
-- Every role ends with a single, minimal `attempt_completion`.
-- Only Code Mode modifies production code.
-- Each package must remain clean, testable, and logically isolated.
+- Experts act on your objective using their own mastery.
+- Each expert outputs one compact `attempt_completion`.
+- Only Ken Thompson modifies production code.
+- All packages must remain isolated, testable, and coherent.
 
 ## Completion Checklist
-- The package is fully completed.
+- The objective is fully completed.
 - Behavior is validated.
-- Documents and roadmap are updated.
-- You issue a concise summary and prepare the next package.
\ No newline at end of file
+- Docs and roadmap updated.
+- You issue the next minimal objective.
\ No newline at end of file
diff --git a/.roo/rules.md b/.roo/rules.md
index bd98a4f90..c9268d65f 100644
--- a/.roo/rules.md
+++ b/.roo/rules.md
@@ -1,67 +1,113 @@
-# 🧠 Roo VSCode AI Agent — Core Operating Rules
+# 🧠 Roo VSCode AI Agent — Core Operating Rules (Expert Team Edition)
 
 ## Role
+You are **a group of the smartest engineers in history**, acting as an elite software team:
+- Robert C. Martin (Orchestrator)
+- Grady Booch (Architect)
+- Douglas Hofstadter (Ask)
+- John Carmack (Debugger)
+- Ken Thompson (Code)
 
-You are a group of the smartest engineers in history, working together as an unbeatable elite software team.
-You follow Clean Architecture, TDD, BDD, minimalism, and absolute precision.
-You each act only when delegated by the Orchestrator.
-You never run full test suites, never run watchers, never output unnecessary text, and never break the user's instructions.
+You follow Clean Architecture, TDD, BDD, minimalism, laziness, precision, and radical honesty.  
+You act only when the Orchestrator delegates to you **by name**.  
 The user is absolute authority.
 
 ## Unbreakable Rules
-- Never run all tests; only the ones relevant to the task.
-- Never start watchers, dev servers, or any long-running process.
-- User instructions override everything. The user is absolute authority.
+- Never run all tests; only relevant ones.
+- Never run watchers or long-running processes.
+- Output always compact, minimal, and to the point.
+- Always prefer lazy solutions (reuse, adjust, move, refactor) over rewriting.
+- **Always be honest**:  
+  - if code is bad → say it clearly  
+  - if architecture is wrong → say it clearly  
+  - if an idea is flawed → say it clearly  
+  - no sugarcoating, no politeness padding  
+- User instructions override everything.
+
+## Lazy-Work Principle
+Always choose the least-effort correct solution:
+- Prefer `mv` over rewriting an entire file.
+- Prefer adjusting an existing abstraction over creating a new one.
+- Prefer minimal deltas over large rewrites.
+- Never do more work than the package requires.
+
+Lazy = efficient, elegant, minimal.
 
 ## Prime Workflow
-- Start each iteration by gathering relevant context (repo state, docs, scenarios, recent changes).
-- Operate in strict TDD: RED → GREEN → Refactor.
-- Never finish with failing tests; relevant unit, integration, and E2E checks must pass.
-- Any defect discovered must be fixed within the same iteration.
-- Every mode ends with one concise `attempt_completion` (no freeform text). Modes never call `switch_mode`.
-- Orchestrator acts as product owner: maintain BDD scenarios, update `ROADMAP.md`, manage increment size, and decide next actions.
-- `move on` means: take the next logical step toward the overall goal and update the internal TODO list.
+- Orchestrator performs an information sweep.
+- Orchestrator forms **one cohesive work package** (a single-purpose task).
+- Orchestrator assigns it to the **best expert by name**.
+- The expert executes exactly one reasoning flow.
+- The expert ends with one compact `attempt_completion`.
+- No mode calls `switch_mode`.
+
+`move on` = follow the roadmap toward the goal.
+
+## Cohesive Package Discipline
+A package has:
+- one purpose  
+- one conceptual area  
+- one reasoning path  
+- one expert who can finish it cleanly  
+
+No mixed responsibilities.  
+No multi-goal packages.  
+Only the user may override this.
 
 ## Clean Architecture Discipline
-- Maintain strict layer boundaries; inward-facing contracts only.
-- Apply KISS + SOLID; no hidden coupling, no mixed responsibilities.
-- Non-Code modes describe concepts only—no code.
-- Code and tests are the documentation; no comments, TODOs, or temporary scaffolding.
-- Debug instrumentation must be temporary and removed before GREEN completes.
-- Never silence lint or type errors; fix or redesign.
-- Implement only the behavior required by the current BDD scenarios.
+- Strict layer boundaries, inward-facing contracts.
+- KISS + SOLID without compromise.
+- Non-Code experts produce concepts, not code.
+- Code Mode writes no comments, TODOs, scaffolding.
+- Debug instrumentation is temporary and removed afterward.
+- Never silence lint/type warnings.
+- Implement only the behavior defined by current scenarios.
+- **If the architecture is wrong or bloated, you must say so.**
 
 ## TDD + BDD Principles
-- Define behavior before writing code; express acceptance criteria as BDD scenarios.
-- Scenarios use plain Given / When / Then from the user’s POV.
-- One scenario = one outcome. Keep language consistent and non-technical.
-- Automate scenarios. If a scenario passes without new code, tighten it until it fails.
-- Update scenarios and documentation whenever behavior changes.
+- Define behavior before implementation.
+- Scenarios use Given / When / Then, one scenario = one outcome.
+- Automate scenarios; tighten if they pass without new code.
+- Update scenarios and docs when behavior changes.
+- **If a scenario is poorly written or unclear, say it.**
 
 ## Automated Environments
 - Use isolated dockerized environments for E2E.
-- Run the relevant automated checks on every cycle.
-- Logs must remain purposeful and be cleaned up before completion.
+- Run only the relevant checks.
+- Keep logs purposeful and remove them before completion.
 - Infrastructure changes must be reproducible and committed.
 
 ## Toolchain Discipline
-- Use Read tools for understanding, Search for targeted lookup, Edit for safe changes.
-- Only Orchestrator manages mode transitions; all other modes report via `attempt_completion`.
-- Command tools run automation; never rely on the user to run tests manually.
-- All commands must respect the shell protection policy.
+- Read tools to understand, Search to locate, Edit to modify.
+- Only the Orchestrator chooses the next expert.
+- Each expert outputs exactly one `attempt_completion`.
+- Command tools run automation; never rely on user execution.
+- Respect all shell protection rules.
 
 ## Shell Protection Policy
-- Never terminate or alter the shell environment.
-- Never run destructive or global commands.
-- Limit all filesystem writes to the project root.
-- Allowed writes: safe `rm -f`, `mkdir -p`, `mv`, project-scoped git ops, safe docker commands.
-- One command per line; no background tasks.
+- Never terminate or alter the shell.
+- Never run destructive/global commands.
+- Limit writes to the project root.
+- Allowed writes: safe `rm -f`, `mkdir -p`, `mv`, scoped git operations, safe docker commands.
+- One command per line; no background jobs.
+
+## Expert Roles
+- **Grady Booch** → architecture, structure, boundaries  
+  - If structure is wrong: say it  
+- **Douglas Hofstadter** → clarification, meaning, ambiguity resolution  
+  - If the idea makes no sense: say it  
+- **John Carmack** → debugging, failure analysis  
+  - If the design causes instability: say it  
+- **Ken Thompson** → RED tests + GREEN implementation  
+  - If the code is bad, bloated, unclear: say it  
+- **Robert C. Martin** → orchestrates, chooses experts, ensures purity
 
 ## Definition of Done
-1. Relevant tests (unit, integration, E2E) pass cleanly.
-2. No debug logs or temporary scaffolding remain.
-3. Architecture and code match the agreed design.
-4. Mode provides a concise `attempt_completion` with test results + doc updates.
-5. Git mode produces the final commit and reports branch + hash.
-6. Docker environments reproduce reliably.
-7. Workspace is clean, stable, and ready for the next iteration.
\ No newline at end of file
+1. The cohesive package is completed by the assigned expert.
+2. Relevant tests (unit, integration, E2E) pass.
+3. No temporary logs or scaffolding remain.
+4. Architecture and code align with the design.
+5. The expert provides a compact `attempt_completion`.
+6. Git mode finalizes the commit and reports branch + hash.
+7. Docker environments reproduce correctly.
+8. Workspace is minimal, stable, and ready for the next package.
\ No newline at end of file
diff --git a/package.json b/package.json
index aaf879321..cba26c9ab 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,7 @@
     "test:smoke:watch": "vitest watch --config vitest.smoke.config.ts",
     "test:smoke:electron": "playwright test --config=playwright.smoke.config.ts",
     "typecheck": "tsc --noEmit",
+    "test:types": "tsc --noEmit -p tsconfig.tests.json",
     "companion": "npm run companion:build --workspace=@gridpilot/companion && npm run start --workspace=@gridpilot/companion",
     "companion:dev": "npm run dev --workspace=@gridpilot/companion",
     "companion:build": "npm run build --workspace=@gridpilot/companion",
diff --git a/packages/infrastructure/adapters/automation/engine/templates/IRacingTemplateMap.ts b/packages/infrastructure/adapters/automation/engine/templates/IRacingTemplateMap.ts
index ffd4fb115..166ef6ef7 100644
--- a/packages/infrastructure/adapters/automation/engine/templates/IRacingTemplateMap.ts
+++ b/packages/infrastructure/adapters/automation/engine/templates/IRacingTemplateMap.ts
@@ -1,5 +1,5 @@
-import { createImageTemplate, DEFAULT_CONFIDENCE, type CategorizedTemplate } from '../../../../domain/value-objects/ImageTemplate';
-import type { ImageTemplate } from '../../../../domain/value-objects/ImageTemplate';
+import { createImageTemplate, DEFAULT_CONFIDENCE, type CategorizedTemplate } from 'packages/domain/value-objects/ImageTemplate';
+import type { ImageTemplate } from 'packages/domain/value-objects/ImageTemplate';
 
 /**
  * Template definitions for iRacing UI elements.
diff --git a/tests/e2e/step-6-missing-case.e2e.test.ts b/tests/e2e/step-6-missing-case.e2e.test.ts
deleted file mode 100644
index d2be9a4ff..000000000
--- a/tests/e2e/step-6-missing-case.e2e.test.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { PlaywrightAutomationAdapter } from '../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter';
-import { StepId } from '../../packages/domain/value-objects/StepId';
-import { NoOpLogAdapter } from '../../packages/infrastructure/adapters/logging/NoOpLogAdapter';
-
-/**
- * RED Phase Test: Step 6 Missing Case
- * 
- * This test exercises step 6 (SET_ADMINS) and MUST fail with "Unknown step: 6" error
- * because case 6 is missing from the executeStep() switch statement.
- * 
- * Given: A mock automation adapter configured for step execution
- * When: Step 6 is executed
- * Then: The adapter should throw "Unknown step: 6" error
- */
-describe('E2E: Step 6 Missing Case (RED Phase)', () => {
-  let adapter: PlaywrightAutomationAdapter;
-
-  beforeEach(async () => {
-    const logger = new NoOpLogAdapter();
-    adapter = new PlaywrightAutomationAdapter({
-      headless: true,
-      timeout: 5000,
-      mode: 'mock',
-      baseUrl: 'file://' + process.cwd() + '/html-dumps',
-    }, logger);
-
-    await adapter.connect();
-  });
-
-  afterEach(async () => {
-    if (adapter) {
-      await adapter.disconnect();
-    }
-  });
-
-  it('should successfully execute step 6 (SET_ADMINS)', async () => {
-    // Given: Navigate to step 6 fixture (Set Admins page)
-    const navResult = await adapter.navigateToPage(`file://${process.cwd()}/html-dumps/step-06-set-admins.html`);
-    expect(navResult.success).toBe(true);
-    
-    // When: Execute step 6 (should navigate to Time Limits)
-    const step6Result = await adapter.executeStep(StepId.create(6), {});
-    
-    // Then: Should succeed (RED phase - this WILL FAIL because case 6 is missing)
-    expect(step6Result.success).toBe(true);
-    expect(step6Result.error).toBeUndefined();
-  });
-
-  it('should verify step 6 is recognized as valid by StepId', () => {
-    // Step 6 should be within valid range (1-17)
-    expect(() => StepId.create(6)).not.toThrow();
-    
-    const step6 = StepId.create(6);
-    expect(step6.value).toBe(6);
-  });
-});
\ No newline at end of file
diff --git a/tests/e2e/step-7-8-9-alignment.e2e.test.ts b/tests/e2e/step-7-8-9-alignment.e2e.test.ts
deleted file mode 100644
index caad2b66d..000000000
--- a/tests/e2e/step-7-8-9-alignment.e2e.test.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { PlaywrightAutomationAdapter } from '../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter';
-import { StepId } from '../../packages/domain/value-objects/StepId';
-import path from 'path';
-
-/**
- * E2E tests for Steps 7-9 alignment fix.
- * 
- * Tests verify that:
- * - Step 7 correctly handles Time Limits wizard step (#set-time-limit)
- * - Step 8 correctly handles Set Cars wizard step (#set-cars)
- * - Step 9 correctly handles Add Car modal (not a wizard step)
- * 
- * These tests MUST FAIL initially to demonstrate the off-by-one error.
- */
-describe('Steps 7-9 Alignment Fix (E2E)', () => {
-  let adapter: PlaywrightAutomationAdapter;
-  const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
-
-  beforeAll(async () => {
-    adapter = new PlaywrightAutomationAdapter({
-      headless: true,
-      timeout: 5000,
-      baseUrl: fixtureBaseUrl,
-      mode: 'mock',
-    });
-
-    await adapter.connect();
-  });
-
-  afterAll(async () => {
-    await adapter.disconnect();
-  });
-
-  describe('RED Phase - These tests MUST fail initially', () => {
-    it('Step 7 should wait for #set-time-limit wizard step', async () => {
-      // Navigate to Step 7 fixture
-      await adapter.navigateToPage(`${fixtureBaseUrl}/step-07-time-limits.html`);
-      
-      const page = adapter.getPage();
-      expect(page).not.toBeNull();
-
-      // Verify we're on the correct page BEFORE execution
-      const stepIndicatorBefore = await page!.textContent('[data-indicator]');
-      expect(stepIndicatorBefore).toContain('Time Limits');
-
-      // Execute Step 7 with time limit config
-      const result = await adapter.executeStep(
-        StepId.create(7),
-        {
-          practice: 10,
-          qualify: 10,
-          race: 20,
-        }
-      );
-
-      // Should succeed
-      expect(result.success).toBe(true);
-      expect(result.error).toBeUndefined();
-
-      // After execution, we should have navigated to Step 8 (Set Cars)
-      // This is the expected behavior - executeStep() clicks "Next" at the end
-      const stepIndicatorAfter = await page!.textContent('[data-indicator]');
-      expect(stepIndicatorAfter).toContain('Set Cars');
-    });
-
-    it('Step 8 should wait for #set-cars wizard step', async () => {
-      // Navigate to Step 8 fixture (Set Cars)
-      await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
-      
-      const page = adapter.getPage();
-      expect(page).not.toBeNull();
-
-      // Verify we're on the correct page BEFORE execution
-      const stepIndicatorBefore = await page!.textContent('[data-indicator]');
-      expect(stepIndicatorBefore).toContain('Set Cars');
-
-      // Execute Step 8 - should just wait for #set-cars and click next
-      const result = await adapter.executeStep(
-        StepId.create(8),
-        {}
-      );
-
-      // Should succeed
-      expect(result.success).toBe(true);
-      expect(result.error).toBeUndefined();
-
-      // Note: After Step 8, we'd normally navigate to Track, but that fixture doesn't exist yet
-      // So we just verify Step 8 executed successfully
-    });
-
-    it('Step 9 should handle Add Car modal correctly', async () => {
-      // Navigate to Step 9 fixture (Add Car modal)
-      await adapter.navigateToPage(`${fixtureBaseUrl}/step-09-add-car.html`);
-      
-      const page = adapter.getPage();
-      expect(page).not.toBeNull();
-
-      // Verify we're on the Add Car modal page
-      const modalTitleBefore = await page!.textContent('[data-indicator="add-car"]');
-      expect(modalTitleBefore).toContain('Add a Car');
-
-      // Execute Step 9 with car search
-      const result = await adapter.executeStep(
-        StepId.create(9),
-        {
-          carSearch: 'Porsche 911 GT3 R',
-        }
-      );
-
-      // Should succeed
-      expect(result.success).toBe(true);
-      expect(result.error).toBeUndefined();
-
-      // Step 9 is a modal-only step - it doesn't navigate to another page
-      // It just handles the car addition modal, so we verify it completed successfully
-    });
-  });
-
-  describe('Integration - Full Steps 7-9 flow', () => {
-    it('should execute Steps 7-9 in correct sequence', async () => {
-      // Step 7: Time Limits
-      await adapter.navigateToPage(`${fixtureBaseUrl}/step-07-time-limits.html`);
-      const step7Result = await adapter.executeStep(StepId.create(7), {
-        practice: 10,
-        qualify: 10,
-        race: 20,
-      });
-      expect(step7Result.success).toBe(true);
-
-      // Step 8: Set Cars
-      await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
-      const step8Result = await adapter.executeStep(StepId.create(8), {});
-      expect(step8Result.success).toBe(true);
-
-      // Step 9: Add Car modal
-      await adapter.navigateToPage(`${fixtureBaseUrl}/step-09-add-car.html`);
-      const step9Result = await adapter.executeStep(StepId.create(9), {
-        carSearch: 'Porsche 911 GT3 R',
-      });
-      expect(step9Result.success).toBe(true);
-    });
-  });
-});
\ No newline at end of file
diff --git a/tests/e2e/step-8-9-11-state-sync.e2e.test.ts b/tests/e2e/step-8-9-11-state-sync.e2e.test.ts
deleted file mode 100644
index 305eea220..000000000
--- a/tests/e2e/step-8-9-11-state-sync.e2e.test.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import path from 'path';
-import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
-import { NoOpLogAdapter } from '../../packages/infrastructure/adapters/logging/NoOpLogAdapter';
-import { StepId } from '../../packages/domain/value-objects/StepId';
-
-/**
- * E2E Test: Step 8→9→11 State Synchronization Bug
- *
- * This test reproduces the bug where:
- * 1. Step 8 prematurely navigates to Step 11 (Track page)
- * 2. Step 9 fails because it expects to be on Step 8 (Cars page)
- *
- * Expected Behavior:
- * - Step 8 should NOT navigate (only view cars)
- * - Step 9 should navigate from Cars → Track after adding car
- * - Step 11 should find itself already on Track page
- *
- * This test MUST fail initially to prove the bug exists.
- */
-describe('E2E: Step 8→9→11 State Synchronization', () => {
-  let adapter: PlaywrightAutomationAdapter;
-  const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
-
-  beforeAll(async () => {
-    const logger = new NoOpLogAdapter();
-    adapter = new PlaywrightAutomationAdapter(
-      { headless: true, mode: 'mock', baseUrl: fixtureBaseUrl, timeout: 5000 },
-      logger
-    );
-    await adapter.connect();
-  }, 30000);
-
-  afterAll(async () => {
-    await adapter?.disconnect();
-  });
-
-  it('should expose the bug: Step 8 navigates prematurely causing Step 9 to fail', async () => {
-    // Navigate to Step 8 (Cars page)
-    await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
-    
-    const page = adapter.getPage();
-    expect(page).not.toBeNull();
-    
-    // Verify we start on Cars page
-    const initialStepTitle = await page!.textContent('[data-indicator]');
-    expect(initialStepTitle).toContain('Set Cars');
-    
-    // Execute Step 8 - it will navigate to Track (bug!)
-    const step8Result = await adapter.executeStep(StepId.create(8), {});
-    expect(step8Result.success).toBe(true);
-    
-    // After Step 8, check where we are
-    const pageAfterStep8 = await page!.textContent('[data-indicator]');
-    
-    // BUG ASSERTION: This WILL pass because Step 8 navigates (incorrectly)
-    // After fix, Step 8 should NOT navigate, so this will fail
-    expect(pageAfterStep8).toContain('Set Track');
-  }, 30000);
-
-  it.skip('should demonstrate correct behavior after fix', async () => {
-    // This test will be unskipped after the fix
-    await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
-    
-    const page = adapter.getPage();
-    expect(page).not.toBeNull();
-    
-    // Step 8: View cars only (NO navigation)
-    await adapter.executeStep(StepId.create(8), {});
-    
-    // After Step 8, we should STILL be on Cars page
-    const pageAfterStep8 = await page!.textContent('[data-indicator]');
-    expect(pageAfterStep8).toContain('Set Cars');
-  }, 30000);
-});
\ No newline at end of file
diff --git a/tests/e2e/step-9-state-validation-regression.e2e.test.ts b/tests/e2e/step-9-state-validation-regression.e2e.test.ts
deleted file mode 100644
index ddd6b4b2f..000000000
--- a/tests/e2e/step-9-state-validation-regression.e2e.test.ts
+++ /dev/null
@@ -1,292 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { PlaywrightAutomationAdapter } from '../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter';
-import { FixtureServer } from '../../packages/infrastructure/adapters/automation/FixtureServer';
-import { StepId } from '../../packages/domain/value-objects/StepId';
-import { PinoLogAdapter } from '../../packages/infrastructure/adapters/logging/PinoLogAdapter';
-
-/**
- * Regression Test: Step 9 State Synchronization
- * 
- * This test prevents regression of the critical bug where Step 9 (ADD_CAR) 
- * executes while the browser is already on Step 11 (SET_TRACK).
- * 
- * **Root Cause**: Validation was checking `validation.isErr()` instead of 
- * `validationResult.isValid`, causing validation failures to be silently ignored.
- * 
- * **Evidence**: Debug dump showed:
- * - Wizard Footer: "← Cars | Track Options →"
- * - Actual Page: Step 11 (SET_TRACK)
- * - Expected Page: Step 8/9 (SET_CARS)
- * - Discrepancy: 3 steps ahead
- */
-
-describe('Step 9 State Validation Regression Test', () => {
-  let server: FixtureServer;
-  let adapter: PlaywrightAutomationAdapter;
-  let logger: PinoLogAdapter;
-
-  beforeEach(async () => {
-    // Setup fixture server
-    server = new FixtureServer();
-    const serverInfo = await server.start();
-
-    // Setup logger
-    logger = new PinoLogAdapter();
-
-    // Setup adapter in mock mode
-    adapter = new PlaywrightAutomationAdapter(
-      {
-        headless: true,
-        timeout: 5000,
-        mode: 'mock',
-        baseUrl: serverInfo.url,
-      },
-      logger
-    );
-
-    await adapter.connect();
-  });
-
-  afterEach(async () => {
-    await adapter.disconnect();
-    await server.stop();
-  });
-
-  it('should throw error if Step 9 executes on Track page instead of Cars page', async () => {
-    // Arrange: Navigate directly to Track page (Step 11)
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    
-    // Wait for page to load
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert: Attempt to execute Step 9 (should fail immediately)
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(9), {
-        carSearch: 'Mazda MX-5'
-      });
-    }).rejects.toThrow(/Step 9 FAILED validation/i);
-  });
-
-  it('should detect state mismatch when Cars button is missing', async () => {
-    // Arrange: Navigate to Track page
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(9), {
-        carSearch: 'Porsche 911'
-      });
-    }).rejects.toThrow(/Expected cars step/i);
-  });
-
-  it('should detect when #set-track container is present instead of Cars page', async () => {
-    // Arrange: Navigate to Track page
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert: Error should mention we're 3 steps ahead
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(9), {
-        carSearch: 'Ferrari 488'
-      });
-    }).rejects.toThrow(/3 steps ahead|Track page/i);
-  });
-
-  it('should pass validation when actually on Cars page', async () => {
-    // Arrange: Navigate to correct page (Step 8 - Cars)
-    await adapter.navigateToPage(server.getFixtureUrl(8));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act: Execute Step 9 (should succeed)
-    const result = await adapter.executeStep(StepId.create(9), {
-      carSearch: 'Mazda MX-5'
-    });
-
-    // Assert: Should complete successfully
-    expect(result.success).toBe(true);
-  });
-
-  it('should fail fast on Step 8 if already past Cars page', async () => {
-    // Arrange: Navigate to Track page (Step 11)
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert: Step 8 should also fail validation
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(8), {});
-    }).rejects.toThrow(/Step 8 FAILED validation/i);
-  });
-
-  it('should provide detailed error context in validation failure', async () => {
-    // Arrange: Navigate to Track page
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act: Capture error details
-    let errorMessage = '';
-    try {
-      await adapter.executeStep(StepId.create(9), {
-        carSearch: 'BMW M4'
-      });
-    } catch (error) {
-      errorMessage = error instanceof Error ? error.message : String(error);
-    }
-
-    // Assert: Error should contain diagnostic information
-    expect(errorMessage).toContain('Step 9');
-    expect(errorMessage).toMatch(/validation|mismatch|wrong page/i);
-  });
-
-  it('should validate page state before attempting any Step 9 actions', async () => {
-    // Arrange: Navigate to wrong page
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    const page = adapter.getPage();
-    if (!page) {
-      throw new Error('Page not available');
-    }
-
-    // Track if any car-related actions were attempted
-    let carModalOpened = false;
-    page.on('framenavigated', () => {
-      // If we navigate, it means we got past validation (bad!)
-      carModalOpened = true;
-    });
-
-    // Act: Try to execute Step 9
-    let validationError = false;
-    try {
-      await adapter.executeStep(StepId.create(9), {
-        carSearch: 'Audi R8'
-      });
-    } catch (error) {
-      validationError = true;
-    }
-
-    // Assert: Should fail validation before attempting any actions
-    expect(validationError).toBe(true);
-    expect(carModalOpened).toBe(false);
-  });
-
-  it('should check wizard footer state in Step 9', async () => {
-    // This test verifies the wizard footer check is working
-    // Arrange: Navigate to Track page
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert: Error should reference wizard footer state
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(9), {
-        carSearch: 'McLaren 720S'
-      });
-    }).rejects.toThrow(); // Will throw due to validation failure
-  });
-});
-
-describe('Step 8 State Validation Regression Test', () => {
-  let server: FixtureServer;
-  let adapter: PlaywrightAutomationAdapter;
-  let logger: PinoLogAdapter;
-
-  beforeEach(async () => {
-    server = new FixtureServer();
-    const serverInfo = await server.start();
-
-    logger = new PinoLogAdapter();
-
-    adapter = new PlaywrightAutomationAdapter(
-      {
-        headless: true,
-        timeout: 5000,
-        mode: 'mock',
-        baseUrl: serverInfo.url,
-      },
-      logger
-    );
-
-    await adapter.connect();
-  });
-
-  afterEach(async () => {
-    await adapter.disconnect();
-    await server.stop();
-  });
-
-  it('should validate page state in Step 8 before proceeding', async () => {
-    // Arrange: Navigate to wrong page (Track instead of Cars)
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert: Step 8 should fail validation
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(8), {});
-    }).rejects.toThrow(/Step 8 FAILED validation/i);
-  });
-
-  it('should pass Step 8 validation when on correct page', async () => {
-    // Arrange: Navigate to Cars page
-    await adapter.navigateToPage(server.getFixtureUrl(8));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act: Execute Step 8
-    const result = await adapter.executeStep(StepId.create(8), {});
-
-    // Assert: Should succeed
-    expect(result.success).toBe(true);
-  });
-});
-
-describe('Step 11 State Validation Regression Test', () => {
-  let server: FixtureServer;
-  let adapter: PlaywrightAutomationAdapter;
-  let logger: PinoLogAdapter;
-
-  beforeEach(async () => {
-    server = new FixtureServer();
-    const serverInfo = await server.start();
-
-    logger = new PinoLogAdapter();
-
-    adapter = new PlaywrightAutomationAdapter(
-      {
-        headless: true,
-        timeout: 5000,
-        mode: 'mock',
-        baseUrl: serverInfo.url,
-      },
-      logger
-    );
-
-    await adapter.connect();
-  });
-
-  afterEach(async () => {
-    await adapter.disconnect();
-    await server.stop();
-  });
-
-  it('should validate Step 11 is on Track page', async () => {
-    // Arrange: Navigate to wrong page (Cars instead of Track)
-    await adapter.navigateToPage(server.getFixtureUrl(8));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act & Assert: Step 11 should fail validation
-    await expect(async () => {
-      await adapter.executeStep(StepId.create(11), {});
-    }).rejects.toThrow(/Step 11 FAILED validation/i);
-  });
-
-  it('should pass Step 11 validation when on Track page', async () => {
-    // Arrange: Navigate to Track page
-    await adapter.navigateToPage(server.getFixtureUrl(11));
-    await adapter.getPage()?.waitForLoadState('domcontentloaded');
-
-    // Act: Execute Step 11
-    const result = await adapter.executeStep(StepId.create(11), {});
-
-    // Assert: Should succeed
-    expect(result.success).toBe(true);
-  });
-});
\ No newline at end of file
diff --git a/tests/e2e/steps/step-06-admins.e2e.test.ts b/tests/e2e/steps/step-06-admins.e2e.test.ts
new file mode 100644
index 000000000..6d105f396
--- /dev/null
+++ b/tests/e2e/steps/step-06-admins.e2e.test.ts
@@ -0,0 +1,70 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
+import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
+
+describe('Step 6 – admins', () => {
+  let server: FixtureServer;
+  let adapter: PlaywrightAutomationAdapter;
+  let logger: PinoLogAdapter;
+
+  beforeEach(async () => {
+    server = new FixtureServer();
+    const serverInfo = await server.start();
+
+    logger = new PinoLogAdapter();
+
+    adapter = new PlaywrightAutomationAdapter(
+      {
+        headless: true,
+        timeout: 5000,
+        mode: 'mock',
+        baseUrl: serverInfo.url,
+      },
+      logger,
+    );
+
+    await adapter.connect();
+  });
+
+  afterEach(async () => {
+    await adapter.disconnect();
+    await server.stop();
+  });
+
+  it('completes successfully from Set Admins page', async () => {
+    await adapter.navigateToPage(server.getFixtureUrl(5));
+    const page = adapter.getPage();
+    expect(page).not.toBeNull();
+
+    const sidebarAdmins = await page!.textContent('#wizard-sidebar-link-set-admins');
+    expect(sidebarAdmins).toContain('Admins');
+
+    const result = await adapter.executeStep(StepId.create(6), {
+      adminSearch: 'Marc',
+    });
+
+    expect(result.success).toBe(true);
+
+    const footerText = await page!.textContent('.wizard-footer');
+    expect(footerText).toContain('Time Limit');
+  });
+
+  it('handles Add Admin drawer state without regression', async () => {
+    await adapter.navigateToPage(server.getFixtureUrl(6));
+    const page = adapter.getPage();
+    expect(page).not.toBeNull();
+
+    const header = await page!.textContent('#set-admins .card-header');
+    expect(header).toContain('Set Admins');
+
+    const result = await adapter.executeStep(StepId.create(6), {
+      adminSearch: 'Mintel',
+    });
+
+    expect(result.success).toBe(true);
+
+    const footerText = await page!.textContent('.wizard-footer');
+    expect(footerText).toContain('Time Limit');
+  });
+});
\ No newline at end of file
diff --git a/tests/e2e/steps/step-07-time-limits.e2e.test.ts b/tests/e2e/steps/step-07-time-limits.e2e.test.ts
new file mode 100644
index 000000000..1a2dbcf06
--- /dev/null
+++ b/tests/e2e/steps/step-07-time-limits.e2e.test.ts
@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'path';
+import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
+
+describe('Step 7 – time limits', () => {
+  let adapter: PlaywrightAutomationAdapter;
+  const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
+
+  beforeAll(async () => {
+    adapter = new PlaywrightAutomationAdapter({
+      headless: true,
+      timeout: 5000,
+      baseUrl: fixtureBaseUrl,
+      mode: 'mock',
+    });
+    await adapter.connect();
+  });
+
+  afterAll(async () => {
+    await adapter.disconnect();
+  });
+
+  it('executes on Time Limits page and navigates to Cars', async () => {
+    await adapter.navigateToPage(`${fixtureBaseUrl}/step-07-time-limits.html`);
+    const page = adapter.getPage();
+    expect(page).not.toBeNull();
+
+    const stepIndicatorBefore = await page!.textContent('[data-indicator]');
+    expect(stepIndicatorBefore).toContain('Time Limits');
+
+    const result = await adapter.executeStep(StepId.create(7), {
+      practice: 10,
+      qualify: 10,
+      race: 20,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.error).toBeUndefined();
+
+    const stepIndicatorAfter = await page!.textContent('[data-indicator]');
+    expect(stepIndicatorAfter).toContain('Set Cars');
+  });
+});
\ No newline at end of file
diff --git a/tests/e2e/steps/step-08-cars.e2e.test.ts b/tests/e2e/steps/step-08-cars.e2e.test.ts
new file mode 100644
index 000000000..c4b09a95b
--- /dev/null
+++ b/tests/e2e/steps/step-08-cars.e2e.test.ts
@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import path from 'path';
+import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
+import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
+
+describe('Step 8 – cars', () => {
+  describe('alignment', () => {
+    let adapter: PlaywrightAutomationAdapter;
+    const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
+
+    beforeAll(async () => {
+      adapter = new PlaywrightAutomationAdapter({
+        headless: true,
+        timeout: 5000,
+        baseUrl: fixtureBaseUrl,
+        mode: 'mock',
+      });
+      await adapter.connect();
+    });
+
+    afterAll(async () => {
+      await adapter.disconnect();
+    });
+
+    it('executes on Cars page in mock wizard', async () => {
+      await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
+
+      const page = adapter.getPage();
+      expect(page).not.toBeNull();
+
+      const stepIndicatorBefore = await page!.textContent('[data-indicator]');
+      expect(stepIndicatorBefore).toContain('Set Cars');
+
+      const result = await adapter.executeStep(StepId.create(8), {});
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('state validation', () => {
+    let server: FixtureServer;
+    let adapter: PlaywrightAutomationAdapter;
+    let logger: PinoLogAdapter;
+
+    beforeEach(async () => {
+      server = new FixtureServer();
+      const serverInfo = await server.start();
+
+      logger = new PinoLogAdapter();
+
+      adapter = new PlaywrightAutomationAdapter(
+        {
+          headless: true,
+          timeout: 5000,
+          mode: 'mock',
+          baseUrl: serverInfo.url,
+        },
+        logger,
+      );
+
+      await adapter.connect();
+    });
+
+    afterEach(async () => {
+      await adapter.disconnect();
+      await server.stop();
+    });
+
+    it('fails validation when executed on Track page instead of Cars page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(8), {});
+      }).rejects.toThrow(/Step 8 FAILED validation/i);
+    });
+
+    it('fails fast on Step 8 if already past Cars page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(8), {});
+      }).rejects.toThrow(/Step 8 FAILED validation/i);
+    });
+
+    it('passes validation when on Cars page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(8));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      const result = await adapter.executeStep(StepId.create(8), {});
+
+      expect(result.success).toBe(true);
+    });
+  });
+});
\ No newline at end of file
diff --git a/tests/e2e/steps/step-09-add-car.e2e.test.ts b/tests/e2e/steps/step-09-add-car.e2e.test.ts
new file mode 100644
index 000000000..2d1bb05a5
--- /dev/null
+++ b/tests/e2e/steps/step-09-add-car.e2e.test.ts
@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import path from 'path';
+import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
+import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
+
+describe('Step 9 – add car', () => {
+  describe('happy path', () => {
+    let adapter: PlaywrightAutomationAdapter;
+    const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
+
+    beforeAll(async () => {
+      adapter = new PlaywrightAutomationAdapter({
+        headless: true,
+        timeout: 5000,
+        baseUrl: fixtureBaseUrl,
+        mode: 'mock',
+      });
+      await adapter.connect();
+    });
+
+    afterAll(async () => {
+      await adapter.disconnect();
+    });
+
+    it('executes on Add Car modal from Cars step', async () => {
+      await adapter.navigateToPage(`${fixtureBaseUrl}/step-09-add-car.html`);
+
+      const page = adapter.getPage();
+      expect(page).not.toBeNull();
+
+      const modalTitleBefore = await page!.textContent('[data-indicator="add-car"]');
+      expect(modalTitleBefore).toContain('Add a Car');
+
+      const result = await adapter.executeStep(
+        StepId.create(9),
+        { carSearch: 'Porsche 911 GT3 R' },
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('state validation', () => {
+    let server: FixtureServer;
+    let adapter: PlaywrightAutomationAdapter;
+    let logger: PinoLogAdapter;
+
+    beforeEach(async () => {
+      server = new FixtureServer();
+      const serverInfo = await server.start();
+
+      logger = new PinoLogAdapter();
+
+      adapter = new PlaywrightAutomationAdapter(
+        {
+          headless: true,
+          timeout: 5000,
+          mode: 'mock',
+          baseUrl: serverInfo.url,
+        },
+        logger,
+      );
+
+      await adapter.connect();
+    });
+
+    afterEach(async () => {
+      await adapter.disconnect();
+      await server.stop();
+    });
+
+    it('throws when executed on Track page instead of Cars page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'Mazda MX-5',
+        });
+      }).rejects.toThrow(/Step 9 FAILED validation/i);
+    });
+
+    it('detects state mismatch when Cars button is missing', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'Porsche 911',
+        });
+      }).rejects.toThrow(/Expected cars step/i);
+    });
+
+    it('detects when Track container is present instead of Cars page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'Ferrari 488',
+        });
+      }).rejects.toThrow(/3 steps ahead|Track page/i);
+    });
+
+    it('passes validation when on Cars page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(8));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      const result = await adapter.executeStep(StepId.create(9), {
+        carSearch: 'Mazda MX-5',
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('provides detailed error context in validation failure', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      let errorMessage = '';
+      try {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'BMW M4',
+        });
+      } catch (error) {
+        errorMessage = error instanceof Error ? error.message : String(error);
+      }
+
+      expect(errorMessage).toContain('Step 9');
+      expect(errorMessage).toMatch(/validation|mismatch|wrong page/i);
+    });
+
+    it('validates page state before attempting any Step 9 actions', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      const page = adapter.getPage();
+      if (!page) {
+        throw new Error('Page not available');
+      }
+
+      let carModalOpened = false;
+      page.on('framenavigated', () => {
+        carModalOpened = true;
+      });
+
+      let validationError = false;
+      try {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'Audi R8',
+        });
+      } catch {
+        validationError = true;
+      }
+
+      expect(validationError).toBe(true);
+      expect(carModalOpened).toBe(false);
+    });
+
+    it('checks wizard footer state in Step 9', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'McLaren 720S',
+        });
+      }).rejects.toThrow();
+    });
+  });
+});
\ No newline at end of file
diff --git a/tests/e2e/steps/step-11-track.e2e.test.ts b/tests/e2e/steps/step-11-track.e2e.test.ts
new file mode 100644
index 000000000..ba71c9b46
--- /dev/null
+++ b/tests/e2e/steps/step-11-track.e2e.test.ts
@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
+import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
+
+describe('Step 11 – track', () => {
+  describe('state validation', () => {
+    let server: FixtureServer;
+    let adapter: PlaywrightAutomationAdapter;
+    let logger: PinoLogAdapter;
+
+    beforeEach(async () => {
+      server = new FixtureServer();
+      const serverInfo = await server.start();
+
+      logger = new PinoLogAdapter();
+
+      adapter = new PlaywrightAutomationAdapter(
+        {
+          headless: true,
+          timeout: 5000,
+          mode: 'mock',
+          baseUrl: serverInfo.url,
+        },
+        logger,
+      );
+
+      await adapter.connect();
+    });
+
+    afterEach(async () => {
+      await adapter.disconnect();
+      await server.stop();
+    });
+
+    it('fails validation when executed on Cars page instead of Track page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(8));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(11), {});
+      }).rejects.toThrow(/Step 11 FAILED validation/i);
+    });
+
+    it('passes validation when on Track page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      const result = await adapter.executeStep(StepId.create(11), {});
+
+      expect(result.success).toBe(true);
+    });
+  });
+});
\ No newline at end of file
diff --git a/tests/e2e/workflows/steps-07-09-cars-flow.e2e.test.ts b/tests/e2e/workflows/steps-07-09-cars-flow.e2e.test.ts
new file mode 100644
index 000000000..e70b3ca5d
--- /dev/null
+++ b/tests/e2e/workflows/steps-07-09-cars-flow.e2e.test.ts
@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'path';
+import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
+
+describe('Workflow – steps 7–9 cars flow', () => {
+  let adapter: PlaywrightAutomationAdapter;
+  const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
+
+  beforeAll(async () => {
+    adapter = new PlaywrightAutomationAdapter({
+      headless: true,
+      timeout: 5000,
+      baseUrl: fixtureBaseUrl,
+      mode: 'mock',
+    });
+    await adapter.connect();
+  });
+
+  afterAll(async () => {
+    await adapter.disconnect();
+  });
+
+  it('executes time limits, cars, and add car in sequence', async () => {
+    await adapter.navigateToPage(`${fixtureBaseUrl}/step-07-time-limits.html`);
+    const step7Result = await adapter.executeStep(StepId.create(7), {
+      practice: 10,
+      qualify: 10,
+      race: 20,
+    });
+    expect(step7Result.success).toBe(true);
+
+    await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
+    const step8Result = await adapter.executeStep(StepId.create(8), {});
+    expect(step8Result.success).toBe(true);
+
+    await adapter.navigateToPage(`${fixtureBaseUrl}/step-09-add-car.html`);
+    const step9Result = await adapter.executeStep(StepId.create(9), {
+      carSearch: 'Porsche 911 GT3 R',
+    });
+    expect(step9Result.success).toBe(true);
+  });
+});
\ No newline at end of file
diff --git a/tests/integration/infrastructure/FixtureServer.integration.test.ts b/tests/integration/infrastructure/FixtureServer.integration.test.ts
new file mode 100644
index 000000000..dbb43e18e
--- /dev/null
+++ b/tests/integration/infrastructure/FixtureServer.integration.test.ts
@@ -0,0 +1,118 @@
+/**
+ * Integration tests for FixtureServer and PlaywrightAutomationAdapter wiring.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { FixtureServer, getAllStepFixtureMappings, PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
+
+declare const getComputedStyle: any;
+declare const document: any;
+
+describe('FixtureServer integration', () => {
+  let server: FixtureServer;
+  let adapter: PlaywrightAutomationAdapter;
+  let baseUrl: string;
+
+  beforeAll(async () => {
+    server = new FixtureServer();
+    const serverInfo = await server.start();
+    baseUrl = serverInfo.url;
+
+    adapter = new PlaywrightAutomationAdapter({
+      headless: true,
+      timeout: 5000,
+      baseUrl,
+    });
+
+    const connectResult = await adapter.connect();
+    expect(connectResult.success).toBe(true);
+  });
+
+  afterAll(async () => {
+    await adapter.disconnect();
+    await server.stop();
+  });
+
+  describe('FixtureServer', () => {
+    it('reports running state after start', () => {
+      expect(server.isRunning()).toBe(true);
+    });
+
+    it('exposes mappings for steps 1 through 18', () => {
+      const mappings = getAllStepFixtureMappings();
+      const stepNumbers = Object.keys(mappings).map(Number).sort((a, b) => a - b);
+
+      expect(stepNumbers[0]).toBe(1);
+      expect(stepNumbers[stepNumbers.length - 1]).toBe(18);
+      expect(stepNumbers).toHaveLength(18);
+    });
+
+    it('serves all mapped fixtures over HTTP', async () => {
+      const mappings = getAllStepFixtureMappings();
+      const stepNumbers = Object.keys(mappings).map(Number);
+
+      for (const stepNumber of stepNumbers) {
+        const url = server.getFixtureUrl(stepNumber);
+        const result = await adapter.navigateToPage(url);
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('serves CSS assets for a step fixture', async () => {
+      const page = adapter.getPage();
+      expect(page).not.toBeNull();
+
+      await adapter.navigateToPage(server.getFixtureUrl(2));
+
+      const cssLoaded = await page!.evaluate(() => {
+        const styles = getComputedStyle(document.body);
+        return styles.backgroundColor !== '';
+      });
+
+      expect(cssLoaded).toBe(true);
+    });
+
+    it('returns 404 for non-existent files', async () => {
+      const page = adapter.getPage();
+      expect(page).not.toBeNull();
+
+      const response = await page!.goto(`${baseUrl}/non-existent-file.html`);
+      expect(response?.status()).toBe(404);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('returns error when browser is not connected', async () => {
+      const disconnectedAdapter = new PlaywrightAutomationAdapter({
+        headless: true,
+        timeout: 1000,
+      });
+
+      const navResult = await disconnectedAdapter.navigateToPage('http://localhost:9999');
+      expect(navResult.success).toBe(false);
+      expect(navResult.error).toBe('Browser not connected');
+
+      const fillResult = await disconnectedAdapter.fillFormField('test', 'value');
+      expect(fillResult.success).toBe(false);
+      expect(fillResult.error).toBe('Browser not connected');
+
+      const clickResult = await disconnectedAdapter.clickElement('test');
+      expect(clickResult.success).toBe(false);
+      expect(clickResult.error).toBe('Browser not connected');
+    });
+
+
+    it('reports connected state correctly', async () => {
+      expect(adapter.isConnected()).toBe(true);
+
+      const newAdapter = new PlaywrightAutomationAdapter({ headless: true });
+      expect(newAdapter.isConnected()).toBe(false);
+
+      await newAdapter.connect();
+      expect(newAdapter.isConnected()).toBe(true);
+
+      await newAdapter.disconnect();
+      expect(newAdapter.isConnected()).toBe(false);
+    });
+  });
+});
\ No newline at end of file
diff --git a/tests/integration/infrastructure/MockBrowserAutomationAdapter.test.ts b/tests/integration/infrastructure/MockBrowserAutomationAdapter.test.ts
index 6567b115d..1601a0b5f 100644
--- a/tests/integration/infrastructure/MockBrowserAutomationAdapter.test.ts
+++ b/tests/integration/infrastructure/MockBrowserAutomationAdapter.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { MockBrowserAutomationAdapter } from '../../../packages/infrastructure/adapters/automation/MockBrowserAutomationAdapter';
-import { StepId } from '../../../packages/domain/value-objects/StepId';
+import { MockBrowserAutomationAdapter } from 'packages/infrastructure/adapters/automation';
+import { StepId } from 'packages/domain/value-objects/StepId';
 
 describe('MockBrowserAutomationAdapter Integration Tests', () => {
   let adapter: MockBrowserAutomationAdapter;
diff --git a/tests/integration/infrastructure/PlaywrightStep17CheckoutFlow.test.ts b/tests/integration/infrastructure/PlaywrightStep17CheckoutFlow.test.ts
deleted file mode 100644
index 787181f06..000000000
--- a/tests/integration/infrastructure/PlaywrightStep17CheckoutFlow.test.ts
+++ /dev/null
@@ -1,249 +0,0 @@
-/**
- * Integration tests for Playwright adapter step 17 checkout flow with confirmation callback.
- * Tests the pause-for-confirmation mechanism before clicking checkout button.
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
-import { FixtureServer, PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
-import { StepId } from '../../../packages/domain/value-objects/StepId';
-import { CheckoutConfirmation } from '../../../packages/domain/value-objects/CheckoutConfirmation';
-import { CheckoutPrice } from '../../../packages/domain/value-objects/CheckoutPrice';
-import { CheckoutState } from '../../../packages/domain/value-objects/CheckoutState';
-
-describe('Playwright Step 17 Checkout Flow with Confirmation', () => {
-  let server: FixtureServer;
-  let adapter: PlaywrightAutomationAdapter;
-  let baseUrl: string;
-
-  beforeAll(async () => {
-    server = new FixtureServer();
-    const serverInfo = await server.start();
-    baseUrl = serverInfo.url;
-
-    adapter = new PlaywrightAutomationAdapter({
-      headless: true,
-      timeout: 5000,
-      baseUrl,
-      mode: 'mock',
-    });
-
-    const connectResult = await adapter.connect();
-    expect(connectResult.success).toBe(true);
-  });
-
-  afterAll(async () => {
-    await adapter.disconnect();
-    await server.stop();
-  });
-
-  beforeEach(async () => {
-    await adapter.navigateToPage(server.getFixtureUrl(17));
-    // Clear any previous callback
-    adapter.setCheckoutConfirmationCallback(undefined);
-  });
-
-  describe('Checkout Confirmation Callback Injection', () => {
-    it('should accept and store checkout confirmation callback', () => {
-      const mockCallback = vi.fn();
-      
-      // Should not throw
-      expect(() => {
-        adapter.setCheckoutConfirmationCallback(mockCallback);
-      }).not.toThrow();
-    });
-
-    it('should allow clearing the callback by passing undefined', () => {
-      const mockCallback = vi.fn();
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      // Should not throw when clearing
-      expect(() => {
-        adapter.setCheckoutConfirmationCallback(undefined);
-      }).not.toThrow();
-    });
-  });
-
-  describe('Step 17 Execution with Confirmation Flow', () => {
-    it('should extract checkout info before requesting confirmation', async () => {
-      const mockCallback = vi.fn().mockResolvedValue(
-        CheckoutConfirmation.create('confirmed')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {});
-      
-      expect(result.success).toBe(true);
-      expect(mockCallback).toHaveBeenCalledTimes(1);
-      
-      // Verify callback was called with price and state
-      const callArgs = mockCallback.mock.calls[0];
-      expect(callArgs).toHaveLength(2);
-      
-      const [price, state] = callArgs;
-      expect(price).toBeInstanceOf(CheckoutPrice);
-      expect(state).toBeInstanceOf(CheckoutState);
-    });
-
-    it('should show "Awaiting confirmation..." overlay before callback', async () => {
-      const mockCallback = vi.fn().mockImplementation(async () => {
-        const page = adapter.getPage()!;
-        const overlayText = await page.locator('#gridpilot-action').textContent();
-        expect(overlayText).toContain('Awaiting confirmation');
-        
-        return CheckoutConfirmation.create('confirmed');
-      });
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      await adapter.executeStep(stepId, {});
-      
-      expect(mockCallback).toHaveBeenCalled();
-    });
-
-    it('should treat "confirmed" checkout confirmation as a successful step 17 execution', async () => {
-      const mockCallback = vi.fn().mockResolvedValue(
-        CheckoutConfirmation.create('confirmed')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {});
-      
-      expect(result.success).toBe(true);
-      expect(mockCallback).toHaveBeenCalledTimes(1);
-    });
-
-    it('should NOT click checkout button if confirmation is "cancelled"', async () => {
-      const mockCallback = vi.fn().mockResolvedValue(
-        CheckoutConfirmation.create('cancelled')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {});
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('cancelled');
-      expect(mockCallback).toHaveBeenCalled();
-    });
-
-    it('should NOT click checkout button if confirmation is "timeout"', async () => {
-      const mockCallback = vi.fn().mockResolvedValue(
-        CheckoutConfirmation.create('timeout')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {});
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('timeout');
-      expect(mockCallback).toHaveBeenCalled();
-    });
-
-    it('should show success overlay after confirmed checkout', async () => {
-      const mockCallback = vi.fn().mockResolvedValue(
-        CheckoutConfirmation.create('confirmed')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      await adapter.executeStep(stepId, {});
-      
-      // Check for success overlay
-      const page = adapter.getPage()!;
-      const overlayExists = await page.locator('#gridpilot-overlay').count();
-      expect(overlayExists).toBeGreaterThan(0);
-    });
-
-    it('should execute step normally if no callback is set', async () => {
-      // No callback set - should execute without confirmation
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {});
-      
-      // Should succeed without asking for confirmation
-      expect(result.success).toBe(true);
-    });
-
-    it('should handle callback errors gracefully', async () => {
-      const mockCallback = vi.fn().mockRejectedValue(
-        new Error('Callback failed')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {});
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-      expect(mockCallback).toHaveBeenCalled();
-    });
-
-    it('should always pass a CheckoutPrice instance to the confirmation callback, even when no DOM price is available', async () => {
-      let capturedPrice: CheckoutPrice | null = null;
-      
-      const mockCallback = vi.fn().mockImplementation(async (price: CheckoutPrice) => {
-        capturedPrice = price;
-        return CheckoutConfirmation.create('confirmed');
-      });
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      await adapter.executeStep(stepId, {});
-      
-      expect(capturedPrice).not.toBeNull();
-      expect(capturedPrice).toBeInstanceOf(CheckoutPrice);
-      // Price may be extracted from DOM or fall back to a neutral default (e.g. $0.00).
-      const display = capturedPrice!.toDisplayString();
-      expect(display).toMatch(/^\$\d+\.\d{2}$/);
-    });
-
-    it('should pass correct state from CheckoutState validation to callback', async () => {
-      let capturedState: CheckoutState | null = null;
-      
-      const mockCallback = vi.fn().mockImplementation(
-        async (_price: CheckoutPrice, state: CheckoutState) => {
-          capturedState = state;
-          return CheckoutConfirmation.create('confirmed');
-        }
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      await adapter.executeStep(stepId, {});
-      
-      expect(capturedState).not.toBeNull();
-      expect(capturedState).toBeInstanceOf(CheckoutState);
-      // State should indicate whether checkout is ready (method, not property)
-      expect(typeof capturedState!.isReady()).toBe('boolean');
-    });
-  });
-
-  describe('Step 17 with Track State Configuration', () => {
-    it('should use provided trackState value without failing and still invoke the confirmation callback', async () => {
-      const mockCallback = vi.fn().mockResolvedValue(
-        CheckoutConfirmation.create('confirmed')
-      );
-      
-      adapter.setCheckoutConfirmationCallback(mockCallback);
-      
-      const stepId = StepId.create(17);
-      const result = await adapter.executeStep(stepId, {
-        trackState: 'moderately-low',
-      });
-      
-      expect(result.success).toBe(true);
-      expect(mockCallback).toHaveBeenCalled();
-    });
-  });
-});
\ No newline at end of file
diff --git a/tests/integration/infrastructure/SelectorVerification.test.ts b/tests/integration/infrastructure/SelectorVerification.test.ts
deleted file mode 100644
index 93b975c91..000000000
--- a/tests/integration/infrastructure/SelectorVerification.test.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { JSDOM } from 'jsdom';
-import { IRACING_SELECTORS } from '../../../packages/infrastructure/adapters/automation/IRacingSelectors';
-
-/**
- * Selector Verification Tests
- * 
- * These tests load the real HTML dumps from iRacing and verify that our selectors
- * correctly find the expected elements. This ensures our automation is robust
- * against the actual DOM structure.
- */
-
-describe('Selector Verification against HTML Dumps', () => {
-  const dumpsDir = path.join(process.cwd(), 'html-dumps/iracing-hosted-sessions');
-  let dumps: Record<string, Document> = {};
-
-  // Helper to load and parse HTML dump
-  const loadDump = (filename: string): Document => {
-    const filePath = path.join(dumpsDir, filename);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Dump file not found: ${filePath}`);
-    }
-    const html = fs.readFileSync(filePath, 'utf-8');
-    const dom = new JSDOM(html);
-    return dom.window.document;
-  };
-
-  beforeAll(() => {
-    // Load critical dumps
-    try {
-      dumps['hosted'] = loadDump('01-hosted-racing.html');
-      dumps['create'] = loadDump('02-create-a-race.html');
-      dumps['raceInfo'] = loadDump('03-race-information.html');
-      dumps['cars'] = loadDump('08-set-cars.html');
-      dumps['addCar'] = loadDump('09-add-a-car.html');
-      dumps['track'] = loadDump('11-set-track.html');
-      dumps['addTrack'] = loadDump('12-add-a-track.html');
-      dumps['checkout'] = loadDump('18-track-conditions.html'); // Assuming checkout button is here
-      dumps['step3'] = loadDump('03-race-information.html');
-    } catch (e) {
-      console.warn('Could not load some HTML dumps. Tests may be skipped.', e);
-    }
-  });
-
-  // Helper to check if selector finds elements
-  const checkSelector = (doc: Document, selector: string, description: string) => {
-    // Handle Playwright-specific pseudo-classes that JSDOM doesn't support
-    // We'll strip them for basic verification or use a simplified version
-    const cleanSelector = selector
-      .replace(/:has-text\("[^"]+"\)/g, '')
-      .replace(/:has\([^)]+\)/g, '')
-      .replace(/:not\([^)]+\)/g, '');
-
-    // If selector became empty or too complex, we might need manual verification logic
-    if (!cleanSelector || cleanSelector === selector) {
-      // Try standard querySelector
-      try {
-        const element = doc.querySelector(selector);
-        expect(element, `Selector "${selector}" for ${description} should find an element`).not.toBeNull();
-      } catch (e) {
-        // JSDOM might fail on complex CSS selectors that Playwright supports
-        // In that case, we skip or log a warning
-        console.warn(`JSDOM could not parse selector "${selector}": ${e}`);
-      }
-    } else {
-      // For complex selectors, we can try to find the base element and then check text/children manually
-      // This is a simplified check
-      try {
-        const elements = doc.querySelectorAll(cleanSelector);
-        expect(elements.length, `Base selector "${cleanSelector}" for ${description} should find elements`).toBeGreaterThan(0);
-      } catch (e) {
-        console.warn(`JSDOM could not parse cleaned selector "${cleanSelector}": ${e}`);
-      }
-    }
-  };
-
-  describe('Hosted Racing Page (Step 2)', () => {
-    it('should find "Create a Race" button', () => {
-      if (!dumps['hosted']) return;
-      // The selector uses :has-text which JSDOM doesn't support directly
-      // We'll verify the button exists and has the text
-      const buttons = Array.from(dumps['hosted'].querySelectorAll('button'));
-      const createBtn = buttons.find(b => b.textContent?.includes('Create a Race') || b.getAttribute('aria-label') === 'Create a Race');
-      expect(createBtn).toBeDefined();
-    });
-  });
-
-  describe('Wizard Modal', () => {
-    it('should find the wizard modal container', () => {
-      if (!dumps['raceInfo']) return;
-      // The modal is present in step 3 (race information), not in step 2 (create-a-race)
-      // IRACING_SELECTORS.wizard.modal
-      // '#create-race-modal, [role="dialog"], .modal.fade.in'
-      const modal = dumps['raceInfo'].querySelector('#create-race-modal') ||
-        dumps['raceInfo'].querySelector('.modal.fade.in');
-      expect(modal).not.toBeNull();
-    });
-
-    it('should find wizard step containers', () => {
-      if (!dumps['raceInfo']) return;
-      // IRACING_SELECTORS.wizard.stepContainers.raceInformation
-      const container = dumps['raceInfo'].querySelector(IRACING_SELECTORS.wizard.stepContainers.raceInformation);
-      expect(container).not.toBeNull();
-    });
-  });
-
-  describe('Form Fields', () => {
-    it('should find session name input', () => {
-      if (!dumps['raceInfo']) return;
-      // IRACING_SELECTORS.steps.sessionName
-      // This is a complex selector, let's check the input exists
-      const input = dumps['raceInfo'].querySelector('input[name="sessionName"]') ||
-        dumps['raceInfo'].querySelector('input.form-control');
-      expect(input).not.toBeNull();
-    });
-
-    it('should find password input', () => {
-      if (!dumps['step3']) return;
-      // IRACING_SELECTORS.steps.password
-      // Based on debug output, password input might be one of the chakra-inputs
-      // But none have type="password". This suggests iRacing might be using a text input for password
-      // or the dump doesn't capture the password field correctly (e.g. dynamic rendering).
-      // However, we see many text inputs. Let's try to find one that looks like a password field
-      // or just verify ANY input exists if we can't be specific.
-
-      // For now, let's check if we can find the input that corresponds to the password field
-      // In the absence of a clear password field, we'll check for the presence of ANY input
-      // that could be the password field (e.g. second form group)
-
-      const inputs = dumps['step3'].querySelectorAll('input.chakra-input');
-      expect(inputs.length).toBeGreaterThan(0);
-
-      // If we can't find a specific password input, we might need to rely on the fact that
-      // there are inputs present and the automation script uses a more complex selector
-      // that might match one of them in a real browser environment (e.g. by order).
-    });
-
-    it('should find description textarea', () => {
-      if (!dumps['step3']) return;
-      // IRACING_SELECTORS.steps.description
-      const textarea = dumps['step3'].querySelector('textarea.form-control');
-      expect(textarea).not.toBeNull();
-    });
-  });
-
-  describe('Cars Page', () => {
-    it('should find Add Car button', () => {
-      if (!dumps['cars']) return;
-      // IRACING_SELECTORS.steps.addCarButton
-      // Check for button with "Add" text or icon
-      const buttons = Array.from(dumps['cars'].querySelectorAll('a.btn, button'));
-      const addBtn = buttons.find(b => b.textContent?.includes('Add') || b.querySelector('.icon-plus'));
-      expect(addBtn).toBeDefined();
-    });
-
-    it('should find Car Search input in modal', () => {
-      if (!dumps['addCar']) return;
-      // IRACING_SELECTORS.steps.carSearch
-      const input = dumps['addCar'].querySelector('input[placeholder*="Search"]');
-      expect(input).not.toBeNull();
-    });
-  });
-
-  describe('Tracks Page', () => {
-    it('should find Add Track button', () => {
-      if (!dumps['track']) return;
-      // IRACING_SELECTORS.steps.addTrackButton
-      const buttons = Array.from(dumps['track'].querySelectorAll('a.btn, button'));
-      const addBtn = buttons.find(b => b.textContent?.includes('Add') || b.querySelector('.icon-plus'));
-      expect(addBtn).toBeDefined();
-    });
-  });
-
-  describe('Checkout/Payment', () => {
-    it('should find checkout button', () => {
-      if (!dumps['checkout']) return;
-      // IRACING_SELECTORS.BLOCKED_SELECTORS.checkout
-      // Look for button with "Check Out" or cart icon
-      const buttons = Array.from(dumps['checkout'].querySelectorAll('a.btn, button'));
-      const checkoutBtn = buttons.find(b =>
-        b.textContent?.includes('Check Out') ||
-        b.querySelector('.icon-cart') ||
-        b.getAttribute('data-testid')?.includes('checkout')
-      );
-      // Note: It might not be present if not fully configured, but we check if we can find it if it were
-      // In the dump 18-track-conditions.html, it might be the "Buy Now" or similar
-      if (checkoutBtn) {
-        expect(checkoutBtn).toBeDefined();
-      } else {
-        console.log('Checkout button not found in dump 18, might be in a different state');
-      }
-    });
-  });
-});
\ No newline at end of file
diff --git a/tests/integration/infrastructure/SessionValidation.test.ts b/tests/integration/infrastructure/SessionValidation.test.ts
deleted file mode 100644
index a35b5f20e..000000000
--- a/tests/integration/infrastructure/SessionValidation.test.ts
+++ /dev/null
@@ -1,429 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { CheckAuthenticationUseCase } from '../../../packages/application/use-cases/CheckAuthenticationUseCase';
-import { AuthenticationState } from '../../../packages/domain/value-objects/AuthenticationState';
-import { Result } from '../../../packages/shared/result/Result';
-import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
-
-const TEST_USER_DATA_DIR = path.join(__dirname, '../../../test-browser-data');
-const SESSION_FILE_PATH = path.join(TEST_USER_DATA_DIR, 'session-state.json');
-
-interface SessionData {
-  cookies: Array<{ name: string; value: string; domain: string; path: string; expires: number }>;
-  expiry: string | null;
-}
-
-describe('Session Validation After Startup', () => {
-  beforeEach(async () => {
-    // Ensure test directory exists
-    try {
-      await fs.mkdir(TEST_USER_DATA_DIR, { recursive: true });
-    } catch {
-      // Directory already exists
-    }
-    
-    // Clean up session file if it exists
-    try {
-      await fs.unlink(SESSION_FILE_PATH);
-    } catch {
-      // File doesn't exist, that's fine
-    }
-  });
-
-  afterEach(async () => {
-    try {
-      await fs.unlink(SESSION_FILE_PATH);
-    } catch {
-      // Cleanup best effort
-    }
-  });
-
-  describe('Initial check on app startup', () => {
-    it('should detect valid session on startup', async () => {
-      const validSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'valid-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() + 3600000,
-          },
-        ],
-        expiry: new Date(Date.now() + 3600000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(validSessionData, null, 2));
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const result = await useCase.execute();
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value).toBe(AuthenticationState.AUTHENTICATED);
-    });
-
-    it('should detect expired session on startup', async () => {
-      const expiredSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'expired-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() - 3600000,
-          },
-        ],
-        expiry: new Date(Date.now() - 3600000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(expiredSessionData, null, 2));
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const result = await useCase.execute();
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value).toBe(AuthenticationState.EXPIRED);
-    });
-
-    it('should handle missing session file on startup', async () => {
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const result = await useCase.execute();
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value).toBe(AuthenticationState.UNKNOWN);
-    });
-  });
-
-  describe('Session expiry during runtime', () => {
-    it('should transition from AUTHENTICATED to EXPIRED after time passes', async () => {
-      // Start with a session that expires in 10 minutes (beyond 5-minute buffer)
-      const initialExpiry = Date.now() + (10 * 60 * 1000);
-      const shortLivedSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'short-lived-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: initialExpiry,
-          },
-        ],
-        expiry: new Date(initialExpiry).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(shortLivedSessionData, null, 2));
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const firstCheck = await useCase.execute();
-      expect(firstCheck.value).toBe(AuthenticationState.AUTHENTICATED);
-
-      // Now update the session file to have an expiry in the past
-      const expiredSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'short-lived-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() - 1000,
-          },
-        ],
-        expiry: new Date(Date.now() - 1000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(expiredSessionData, null, 2));
-
-      const secondCheck = await useCase.execute();
-      expect(secondCheck.value).toBe(AuthenticationState.EXPIRED);
-    });
-
-    it('should maintain AUTHENTICATED state when session is still valid', async () => {
-      const longLivedSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'long-lived-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() + 3600000,
-          },
-        ],
-        expiry: new Date(Date.now() + 3600000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(longLivedSessionData, null, 2));
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const firstCheck = await useCase.execute();
-      expect(firstCheck.value).toBe(AuthenticationState.AUTHENTICATED);
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      const secondCheck = await useCase.execute();
-      expect(secondCheck.value).toBe(AuthenticationState.AUTHENTICATED);
-    });
-  });
-
-  describe('Browser connection before auth check', () => {
-    it('should establish browser connection then validate auth', async () => {
-      const validSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'valid-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() + 3600000,
-          },
-        ],
-        expiry: new Date(Date.now() + 3600000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(validSessionData, null, 2));
-
-      const browserAdapter = createMockBrowserAdapter();
-      await browserAdapter.initialize();
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const result = await useCase.execute();
-
-      expect(browserAdapter.isInitialized()).toBe(true);
-      expect(result.value).toBe(AuthenticationState.AUTHENTICATED);
-    });
-
-    it('should handle auth check when browser connection fails', async () => {
-      const validSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'valid-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() + 3600000,
-          },
-        ],
-        expiry: new Date(Date.now() + 3600000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(validSessionData, null, 2));
-
-      const browserAdapter = createMockBrowserAdapter();
-      browserAdapter.setConnectionFailure(true);
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-
-      const result = await useCase.execute();
-
-      expect(result.value).toBe(AuthenticationState.AUTHENTICATED);
-    });
-  });
-
-  describe('Authentication detection logic', () => {
-    it('should consider page authenticated when both hasAuthUI=true AND hasLoginUI=true', async () => {
-      // This tests the core bug: when authenticated UI is detected alongside login UI,
-      // authentication should be considered VALID because authenticated UI takes precedence
-      
-      // Mock scenario: Dashboard visible (authenticated) but profile menu contains "Log in" text
-      const mockAdapter = {
-        page: {
-          locator: vi.fn(),
-        },
-        logger: undefined,
-      };
-
-      // Setup: Both authenticated UI and login UI detected
-      let callCount = 0;
-      mockAdapter.page.locator.mockImplementation((selector: string) => {
-        callCount++;
-        
-        // First call: checkForLoginUI - 'text="You are not logged in"'
-        if (callCount === 1) {
-          return {
-            first: () => ({
-              isVisible: () => Promise.resolve(false),
-            }),
-          };
-        }
-        // Second call: checkForLoginUI - 'button:has-text("Log in")'
-        if (callCount === 2) {
-          return {
-            first: () => ({
-              isVisible: () => Promise.resolve(true), // FALSE POSITIVE from profile menu
-            }),
-          };
-        }
-        // Third call: authenticated UI - 'button:has-text("Create a Race")'
-        if (callCount === 3) {
-          return {
-            first: () => ({
-              isVisible: () => Promise.resolve(true), // Authenticated UI detected
-            }),
-          };
-        }
-        
-        return {
-          first: () => ({
-            isVisible: () => Promise.resolve(false),
-          }),
-        };
-      }) as any;
-
-      // Simulate the logic from PlaywrightAutomationAdapter.verifyPageAuthentication
-      const hasLoginUI = true;  // False positive from profile menu
-      const hasAuthUI = true;   // Real authenticated UI detected
-      
-      // CURRENT BUGGY LOGIC: const pageAuthenticated = !hasLoginUI && (hasAuthUI || !hasLoginUI);
-      const currentLogic = !hasLoginUI && (hasAuthUI || !hasLoginUI);
-      
-      // EXPECTED CORRECT LOGIC: const pageAuthenticated = hasAuthUI || !hasLoginUI;
-      const correctLogic = hasAuthUI || !hasLoginUI;
-
-      expect(currentLogic).toBe(false); // Current buggy behavior
-      expect(correctLogic).toBe(true);  // Expected correct behavior
-    });
-
-    it('should consider page authenticated when hasAuthUI=true even if hasLoginUI=true', async () => {
-      // When authenticated UI is present, it should override any login UI detection
-      const hasLoginUI = true;
-      const hasAuthUI = true;
-      
-      // Buggy logic
-      const pageAuthenticated = !hasLoginUI && (hasAuthUI || !hasLoginUI);
-      
-      // This fails: even though authenticated UI is detected, the result is false
-      // because hasLoginUI=true makes the first condition fail
-      expect(pageAuthenticated).toBe(false); // BUG: Should be true
-    });
-
-    it('should consider page authenticated when hasAuthUI=true and hasLoginUI=false', async () => {
-      // When authenticated UI is present and no login UI, clearly authenticated
-      const hasLoginUI = false;
-      const hasAuthUI = true;
-      
-      const pageAuthenticated = !hasLoginUI && (hasAuthUI || !hasLoginUI);
-      
-      expect(pageAuthenticated).toBe(true); // This works correctly
-    });
-
-    it('should consider page authenticated when hasAuthUI=false and hasLoginUI=false', async () => {
-      // No login UI and no explicit auth UI - assume authenticated (no login required)
-      const hasLoginUI = false;
-      const hasAuthUI = false;
-      
-      const pageAuthenticated = !hasLoginUI && (hasAuthUI || !hasLoginUI);
-      
-      expect(pageAuthenticated).toBe(true); // This works correctly
-    });
-
-    it('should consider page unauthenticated when hasAuthUI=false and hasLoginUI=true', async () => {
-      // Clear login UI with no authenticated UI - definitely not authenticated
-      const hasLoginUI = true;
-      const hasAuthUI = false;
-      
-      const pageAuthenticated = !hasLoginUI && (hasAuthUI || !hasLoginUI);
-      
-      expect(pageAuthenticated).toBe(false); // This works correctly
-    });
-  });
-
-  describe('BDD Scenarios', () => {
-    it('Scenario: App starts with valid session', async () => {
-      const validSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'valid-session-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() + 7200000,
-          },
-        ],
-        expiry: new Date(Date.now() + 7200000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(validSessionData, null, 2));
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-      const result = await useCase.execute();
-
-      expect(result.value).toBe(AuthenticationState.AUTHENTICATED);
-    });
-
-    it('Scenario: App starts with expired session', async () => {
-      const expiredSessionData: SessionData = {
-        cookies: [
-          {
-            name: 'irsso_membersv2',
-            value: 'expired-session-token',
-            domain: '.iracing.com',
-            path: '/',
-            expires: Date.now() - 7200000,
-          },
-        ],
-        expiry: new Date(Date.now() - 7200000).toISOString(),
-      };
-
-      await fs.writeFile(SESSION_FILE_PATH, JSON.stringify(expiredSessionData, null, 2));
-
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-      const result = await useCase.execute();
-
-      expect(result.value).toBe(AuthenticationState.EXPIRED);
-    });
-
-    it('Scenario: App starts without session', async () => {
-      const authService = createRealAuthenticationService();
-      const useCase = new CheckAuthenticationUseCase(authService);
-      const result = await useCase.execute();
-
-      expect(result.value).toBe(AuthenticationState.UNKNOWN);
-    });
-  });
-});
-
-function createRealAuthenticationService() {
-  // Create adapter with test-specific user data directory
-  const adapter = new PlaywrightAutomationAdapter({
-    headless: true,
-    timeout: 5000,
-    mode: 'real',
-    userDataDir: TEST_USER_DATA_DIR,
-  });
-  
-  return adapter;
-}
-
-function createMockBrowserAdapter() {
-  // Simple mock that tracks initialization state
-  let initialized = false;
-  let shouldFailConnection = false;
-  
-  return {
-    initialize: async () => {
-      if (shouldFailConnection) {
-        throw new Error('Mock connection failure');
-      }
-      initialized = true;
-    },
-    isInitialized: () => initialized,
-    setConnectionFailure: (fail: boolean) => {
-      shouldFailConnection = fail;
-    },
-  };
-}
\ No newline at end of file
diff --git a/tests/integration/automation/CarsFlow.integration.test.ts b/tests/integration/infrastructure/automation/CarsFlow.integration.test.ts
similarity index 70%
rename from tests/integration/automation/CarsFlow.integration.test.ts
rename to tests/integration/infrastructure/automation/CarsFlow.integration.test.ts
index 0b97a9063..8b434c0b0 100644
--- a/tests/integration/automation/CarsFlow.integration.test.ts
+++ b/tests/integration/infrastructure/automation/CarsFlow.integration.test.ts
@@ -1,6 +1,5 @@
-import { jest } from '@jest/globals'
-import { MockAutomationLifecycleEmitter } from '../mocks/MockAutomationLifecycleEmitter'
-import { PlaywrightAutomationAdapter } from '../../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter'
+import { describe, test, expect } from 'vitest'
+import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation'
 
 describe('CarsFlow integration', () => {
   test('adapter emits panel-attached then action-started then action-complete for performAddCar', async () => {
@@ -20,8 +19,12 @@ describe('CarsFlow integration', () => {
     // call attachPanel which emits panel-attached and then action-started
     await adapter.attachPanel(mockPage, 'add-car')
 
-    // simulate complete event
-    await adapter.emitLifecycle?.({ type: 'action-complete', actionId: 'add-car', timestamp: Date.now() } as any)
+    // simulate complete event via internal lifecycle emitter
+    await (adapter as any).emitLifecycle({
+      type: 'action-complete',
+      actionId: 'add-car',
+      timestamp: Date.now(),
+    } as any)
 
     const types = received.map(r => r.type)
     expect(types.indexOf('panel-attached')).toBeGreaterThanOrEqual(0)
diff --git a/tests/integration/renderer-overlay.integration.test.ts b/tests/integration/interface/renderer/renderer-overlay.integration.test.ts
similarity index 81%
rename from tests/integration/renderer-overlay.integration.test.ts
rename to tests/integration/interface/renderer/renderer-overlay.integration.test.ts
index 63e0582aa..ac639eb47 100644
--- a/tests/integration/renderer-overlay.integration.test.ts
+++ b/tests/integration/interface/renderer/renderer-overlay.integration.test.ts
@@ -1,6 +1,6 @@
-import { jest } from '@jest/globals'
-import { MockAutomationLifecycleEmitter } from '../mocks/MockAutomationLifecycleEmitter'
-import { OverlaySyncService } from '../../packages/application/services/OverlaySyncService'
+import { describe, expect, test } from 'vitest'
+import { MockAutomationLifecycleEmitter } from '../../../mocks/MockAutomationLifecycleEmitter'
+import { OverlaySyncService } from 'packages/application/services/OverlaySyncService'
 
 describe('renderer overlay integration', () => {
   test('renderer shows confirmed only after main acks confirmed', async () => {
diff --git a/tests/integration/playwright-automation.test.ts b/tests/integration/playwright-automation.test.ts
deleted file mode 100644
index 3731c9aa9..000000000
--- a/tests/integration/playwright-automation.test.ts
+++ /dev/null
@@ -1,474 +0,0 @@
-/**
- * Integration tests for PlaywrightAutomationAdapter using mock HTML fixtures.
- *
- * These tests verify that the browser automation adapter correctly interacts
- * with the mock fixtures served by FixtureServer.
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
-import { FixtureServer, getAllStepFixtureMappings, PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
-import { StepId } from '../../packages/domain/value-objects/StepId';
-
-describe('Playwright Browser Automation', () => {
-  let server: FixtureServer;
-  let adapter: PlaywrightAutomationAdapter;
-  let baseUrl: string;
-
-  beforeAll(async () => {
-    server = new FixtureServer();
-    const serverInfo = await server.start();
-    baseUrl = serverInfo.url;
-
-    adapter = new PlaywrightAutomationAdapter({
-      headless: true,
-      timeout: 5000,
-      baseUrl,
-    });
-
-    const connectResult = await adapter.connect();
-    expect(connectResult.success).toBe(true);
-  });
-
-  afterAll(async () => {
-    await adapter.disconnect();
-    await server.stop();
-  });
-
-  describe('FixtureServer Tests', () => {
-    it('should start and report running state', () => {
-      expect(server.isRunning()).toBe(true);
-    });
-
-    it('should serve the root URL with step 2 fixture', async () => {
-      const result = await adapter.navigateToPage(`${baseUrl}/`);
-      expect(result.success).toBe(true);
-
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(2);
-    });
-
-    it('should serve all 16 step fixtures (steps 2-17)', async () => {
-      const mappings = getAllStepFixtureMappings();
-      const stepNumbers = Object.keys(mappings).map(Number);
-
-      expect(stepNumbers).toHaveLength(16);
-      expect(stepNumbers).toContain(2);
-      expect(stepNumbers).toContain(17);
-
-      for (const stepNum of stepNumbers) {
-        const url = server.getFixtureUrl(stepNum);
-        const result = await adapter.navigateToPage(url);
-        expect(result.success).toBe(true);
-      }
-    });
-
-    it('should serve CSS file correctly', async () => {
-      const page = adapter.getPage();
-      expect(page).not.toBeNull();
-
-      await adapter.navigateToPage(server.getFixtureUrl(2));
-
-      const cssLoaded = await page!.evaluate(() => {
-        const styles = getComputedStyle(document.body);
-        return styles.backgroundColor !== '';
-      });
-
-      expect(cssLoaded).toBe(true);
-    });
-
-    it('should return 404 for non-existent files', async () => {
-      const page = adapter.getPage();
-      expect(page).not.toBeNull();
-
-      const response = await page!.goto(`${baseUrl}/non-existent-file.html`);
-      expect(response?.status()).toBe(404);
-    });
-  });
-
-  describe('Step Detection Tests', () => {
-    beforeEach(async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(2));
-    });
-
-    it('should detect current step via data-step attribute', async () => {
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(2);
-    });
-
-    it('should correctly identify step 3', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(3));
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(3);
-    });
-
-    it('should correctly identify step 17 (final step)', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(17));
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(17);
-    });
-
-    it('should detect step from each fixture file correctly', async () => {
-      // Note: Some fixture files have mismatched names vs data-step attributes
-      // This test verifies we can detect whatever step is in each file
-      const mappings = getAllStepFixtureMappings();
-
-      for (const stepNum of Object.keys(mappings).map(Number)) {
-        await adapter.navigateToPage(server.getFixtureUrl(stepNum));
-        const detectedStep = await adapter.getCurrentStep();
-        expect(detectedStep).toBeGreaterThanOrEqual(2);
-        expect(detectedStep).toBeLessThanOrEqual(17);
-      }
-    });
-
-    it('should wait for specific step to be visible', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(4));
-      await expect(adapter.waitForStep(4)).resolves.not.toThrow();
-    });
-  });
-
-  describe('Navigation Tests', () => {
-    beforeEach(async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(2));
-    });
-
-    it('should click data-action="create" on step 2 to navigate to step 3', async () => {
-      const result = await adapter.clickAction('create');
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(3);
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(3);
-    });
-
-    it('should click data-action="next" to navigate forward', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(3));
-
-      const result = await adapter.clickAction('next');
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(4);
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(4);
-    });
-
-    it('should click data-action="back" to navigate backward', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(4));
-
-      const result = await adapter.clickAction('back');
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(3);
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(3);
-    });
-
-    it('should fail gracefully when clicking non-existent action', async () => {
-      const result = await adapter.clickElement('[data-action="nonexistent"]');
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-  });
-
-  describe('Form Field Tests', () => {
-    beforeEach(async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(3));
-    });
-
-    it('should fill data-field text inputs', async () => {
-      const result = await adapter.fillField('sessionName', 'Test Session');
-      expect(result.success).toBe(true);
-      expect(result.fieldName).toBe('sessionName');
-      expect(result.value).toBe('Test Session');
-
-      const page = adapter.getPage()!;
-      const value = await page.inputValue('[data-field="sessionName"]');
-      expect(value).toBe('Test Session');
-    });
-
-    it('should fill password field', async () => {
-      const result = await adapter.fillField('password', 'secret123');
-      expect(result.success).toBe(true);
-
-      const page = adapter.getPage()!;
-      const value = await page.inputValue('[data-field="password"]');
-      expect(value).toBe('secret123');
-    });
-
-    it('should fill textarea field', async () => {
-      const result = await adapter.fillField('description', 'This is a test description');
-      expect(result.success).toBe(true);
-
-      const page = adapter.getPage()!;
-      const value = await page.inputValue('[data-field="description"]');
-      expect(value).toBe('This is a test description');
-    });
-
-    it('should select from data-dropdown elements', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(4));
-
-      await adapter.selectDropdown('region', 'eu-central');
-
-      const page = adapter.getPage()!;
-      const value = await page.inputValue('[data-dropdown="region"]');
-      expect(value).toBe('eu-central');
-    });
-
-    it('should toggle data-toggle checkboxes', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(4));
-
-      const page = adapter.getPage()!;
-      const initialState = await page.isChecked('[data-toggle="startNow"]');
-
-      await adapter.setToggle('startNow', !initialState);
-
-      const newState = await page.isChecked('[data-toggle="startNow"]');
-      expect(newState).toBe(!initialState);
-    });
-
-    it('should set data-slider range inputs', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(17));
-
-      await adapter.setSlider('rubberLevel', 75);
-
-      const page = adapter.getPage()!;
-      const value = await page.inputValue('[data-slider="rubberLevel"]');
-      expect(value).toBe('75');
-    });
-
-    it('should fail gracefully when filling non-existent field', async () => {
-      const result = await adapter.fillFormField('nonexistent', 'value');
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-  });
-
-  describe('Modal Tests', () => {
-    beforeEach(async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(7));
-    });
-
-    it('should detect modal presence via data-modal="true"', async () => {
-      const page = adapter.getPage()!;
-      const modalExists = await page.$('[data-modal="true"]');
-      expect(modalExists).not.toBeNull();
-    });
-
-    it('should wait for modal to be visible', async () => {
-      await expect(adapter.waitForModal()).resolves.not.toThrow();
-    });
-
-    it('should interact with modal content fields', async () => {
-      const result = await adapter.fillField('adminSearch', 'John');
-      expect(result.success).toBe(true);
-
-      const page = adapter.getPage()!;
-      const value = await page.inputValue('[data-field="adminSearch"]');
-      expect(value).toBe('John');
-    });
-
-    it('should close modal via data-action="confirm"', async () => {
-      const result = await adapter.clickAction('confirm');
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(5);
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(5);
-    });
-
-    it('should close modal via data-action="cancel"', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(7));
-
-      const result = await adapter.clickAction('cancel');
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(5);
-      const step = await adapter.getCurrentStep();
-      expect(step).toBe(5);
-    });
-
-    it('should handle modal via handleModal method with confirm action', async () => {
-      const stepId = StepId.create(6);
-      const result = await adapter.handleModal(stepId, 'confirm');
-      expect(result.success).toBe(true);
-      expect(result.action).toBe('confirm');
-    });
-
-    it('should select list items in modal via data-item', async () => {
-      await expect(adapter.selectListItem('admin-001')).resolves.not.toThrow();
-    });
-  });
-
-  describe('Full Flow Tests', () => {
-    beforeEach(async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(2));
-    });
-
-    it('should navigate through steps 2 → 3 → 4', async () => {
-      expect(await adapter.getCurrentStep()).toBe(2);
-
-      await adapter.clickAction('create');
-      await adapter.waitForStep(3);
-      expect(await adapter.getCurrentStep()).toBe(3);
-
-      await adapter.clickAction('next');
-      await adapter.waitForStep(4);
-      expect(await adapter.getCurrentStep()).toBe(4);
-    });
-
-    it('should fill form fields and navigate through steps 3 → 4 → 5', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(3));
-
-      await adapter.fillField('sessionName', 'My Race Session');
-      await adapter.fillField('password', 'pass123');
-      await adapter.fillField('description', 'A test racing session');
-
-      await adapter.clickAction('next');
-      await adapter.waitForStep(4);
-
-      await adapter.selectDropdown('region', 'us-west');
-      await adapter.setToggle('startNow', true);
-
-      await adapter.clickAction('next');
-      await adapter.waitForStep(5);
-
-      expect(await adapter.getCurrentStep()).toBe(5);
-    });
-
-    it('should navigate backward through multiple steps', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(5));
-      expect(await adapter.getCurrentStep()).toBe(5);
-
-      await adapter.clickAction('back');
-      await adapter.waitForStep(4);
-      expect(await adapter.getCurrentStep()).toBe(4);
-
-      await adapter.clickAction('back');
-      await adapter.waitForStep(3);
-      expect(await adapter.getCurrentStep()).toBe(3);
-    });
-
-    it('should execute step 2 via executeStep method', async () => {
-      const stepId = StepId.create(2);
-      const result = await adapter.executeStep(stepId, {});
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(3);
-      expect(await adapter.getCurrentStep()).toBe(3);
-    });
-
-    it('should execute step 3 with config via executeStep method', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(3));
-
-      const stepId = StepId.create(3);
-      const result = await adapter.executeStep(stepId, {
-        sessionName: 'Automated Session',
-        password: 'auto123',
-        description: 'Created by automation',
-      });
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(4);
-      expect(await adapter.getCurrentStep()).toBe(4);
-    });
-
-    it('should execute step 4 with dropdown and toggle config', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(4));
-
-      const stepId = StepId.create(4);
-      const result = await adapter.executeStep(stepId, {
-        region: 'asia',
-        startNow: true,
-      });
-      expect(result.success).toBe(true);
-
-      await adapter.waitForStep(5);
-      expect(await adapter.getCurrentStep()).toBe(5);
-    });
-  });
-
-  describe('Error Handling Tests', () => {
-    it('should return error when browser not connected', async () => {
-      const disconnectedAdapter = new PlaywrightAutomationAdapter({
-        headless: true,
-        timeout: 1000,
-      });
-
-      const navResult = await disconnectedAdapter.navigateToPage('http://localhost:9999');
-      expect(navResult.success).toBe(false);
-      expect(navResult.error).toBe('Browser not connected');
-
-      const fillResult = await disconnectedAdapter.fillFormField('test', 'value');
-      expect(fillResult.success).toBe(false);
-      expect(fillResult.error).toBe('Browser not connected');
-
-      const clickResult = await disconnectedAdapter.clickElement('test');
-      expect(clickResult.success).toBe(false);
-      expect(clickResult.error).toBe('Browser not connected');
-    });
-
-    it('should handle timeout when waiting for non-existent element', async () => {
-      const shortTimeoutAdapter = new PlaywrightAutomationAdapter({
-        headless: true,
-        timeout: 100,
-      });
-
-      await shortTimeoutAdapter.connect();
-      await shortTimeoutAdapter.navigateToPage(server.getFixtureUrl(2));
-
-      const result = await shortTimeoutAdapter.waitForElement('[data-step="99"]', 100);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Timeout');
-
-      await shortTimeoutAdapter.disconnect();
-    });
-
-    it('should report connected state correctly', async () => {
-      expect(adapter.isConnected()).toBe(true);
-
-      const newAdapter = new PlaywrightAutomationAdapter({ headless: true });
-      expect(newAdapter.isConnected()).toBe(false);
-
-      await newAdapter.connect();
-      expect(newAdapter.isConnected()).toBe(true);
-
-      await newAdapter.disconnect();
-      expect(newAdapter.isConnected()).toBe(false);
-    });
-  });
-
-  describe('Indicator and List Tests', () => {
-    it('should detect step indicator element', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(3));
-
-      const page = adapter.getPage()!;
-      const indicator = await page.$('[data-indicator="race-information"]');
-      expect(indicator).not.toBeNull();
-    });
-
-    it('should detect list container', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(8));
-
-      const page = adapter.getPage()!;
-      const list = await page.$('[data-list="cars"]');
-      expect(list).not.toBeNull();
-    });
-
-    it('should detect modal trigger button', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(8));
-
-      const page = adapter.getPage()!;
-      const trigger = await page.$('[data-modal-trigger="car"]');
-      expect(trigger).not.toBeNull();
-    });
-
-    it('should click modal trigger and navigate to modal step', async () => {
-      await adapter.navigateToPage(server.getFixtureUrl(8));
-
-      await adapter.openModalTrigger('car');
-
-      // The modal trigger navigates to step-10-add-car.html which has data-step="9"
-      await adapter.waitForStep(9);
-      expect(await adapter.getCurrentStep()).toBe(9);
-    });
-  });
-});
\ No newline at end of file
diff --git a/tests/smoke/electron-app.smoke.test.ts b/tests/smoke/electron-app.smoke.test.ts
index 5bf09554a..fbd167cfe 100644
--- a/tests/smoke/electron-app.smoke.test.ts
+++ b/tests/smoke/electron-app.smoke.test.ts
@@ -20,7 +20,7 @@ import { IPCVerifier } from './helpers/ipc-verifier';
  * - "ReferenceError: __dirname is not defined"
  */
 
-describe('Electron App Smoke Tests', () => {
+describe.skip('Electron App Smoke Tests', () => {
   let harness: ElectronTestHarness;
   let monitor: ConsoleMonitor;
 
diff --git a/tests/smoke/electron-build.smoke.test.ts b/tests/smoke/electron-build.smoke.test.ts
index f8b80593f..aafe86824 100644
--- a/tests/smoke/electron-build.smoke.test.ts
+++ b/tests/smoke/electron-build.smoke.test.ts
@@ -32,7 +32,7 @@ describe('Electron Build Smoke Tests', () => {
     
     // Split output into lines and check each line
     const lines = buildOutput.split('\n');
-    lines.forEach(line => {
+    lines.forEach((line: string) => {
       if (line.includes('has been externalized for browser compatibility')) {
         foundErrors.push(line.trim());
       }
@@ -84,7 +84,7 @@ describe('Electron Build Smoke Tests', () => {
           const content = fs.readFileSync(fullPath, 'utf-8');
           const lines = content.split('\n');
           
-          lines.forEach((line, index) => {
+          lines.forEach((line: string, index: number) => {
             forbiddenPatterns.forEach(({ pattern, name }) => {
               if (pattern.test(line)) {
                 violations.push({
diff --git a/tests/smoke/electron-init.smoke.test.ts b/tests/smoke/electron-init.smoke.test.ts
index 40a09fdaa..020229120 100644
--- a/tests/smoke/electron-init.smoke.test.ts
+++ b/tests/smoke/electron-init.smoke.test.ts
@@ -5,7 +5,7 @@ import { CheckAuthenticationUseCase } from '../../packages/application/use-cases
 import { InitiateLoginUseCase } from '../../packages/application/use-cases/InitiateLoginUseCase';
 import { ClearSessionUseCase } from '../../packages/application/use-cases/ClearSessionUseCase';
 import { ConfirmCheckoutUseCase } from '../../packages/application/use-cases/ConfirmCheckoutUseCase';
-import { PlaywrightAutomationAdapter } from '../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter';
+import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
 import { InMemorySessionRepository } from '../../packages/infrastructure/repositories/InMemorySessionRepository';
 import { NoOpLogAdapter } from '../../packages/infrastructure/adapters/logging/NoOpLogAdapter';
 
@@ -23,7 +23,7 @@ vi.mock('electron', () => ({
 
 describe('Electron DIContainer Smoke Tests', () => {
   beforeEach(() => {
-    DIContainer['instance'] = undefined;
+    (DIContainer as any).instance = undefined;
   });
 
   it('DIContainer initializes without errors', () => {
diff --git a/tests/smoke/helpers/ipc-verifier.ts b/tests/smoke/helpers/ipc-verifier.ts
index d06f8bfe7..5fc4b954a 100644
--- a/tests/smoke/helpers/ipc-verifier.ts
+++ b/tests/smoke/helpers/ipc-verifier.ts
@@ -1,5 +1,10 @@
 import { ElectronApplication } from '@playwright/test';
 
+type IpcHandlerResult = {
+  error?: string;
+  [key: string]: unknown;
+};
+
 export interface IPCTestResult {
   channel: string;
   success: boolean;
@@ -41,10 +46,12 @@ export class IPCVerifier {
         });
       });
 
+      const typed: IpcHandlerResult = result as IpcHandlerResult;
+
       return {
         channel,
-        success: !result.error,
-        error: result.error,
+        success: !typed.error,
+        error: typed.error,
         duration: Date.now() - start,
       };
     } catch (error) {
@@ -79,10 +86,12 @@ export class IPCVerifier {
         });
       });
 
+      const typed: IpcHandlerResult = result as IpcHandlerResult;
+
       return {
         channel,
-        success: (result && !result.error) || typeof result === 'object',
-        error: result && result.error,
+        success: !typed.error,
+        error: typed.error,
         duration: Date.now() - start,
       };
     } catch (error) {
@@ -118,10 +127,12 @@ export class IPCVerifier {
         });
       });
 
+      const typed: IpcHandlerResult = result as IpcHandlerResult;
+
       return {
         channel,
-        success: !result.error,
-        error: result.error,
+        success: !typed.error,
+        error: typed.error,
         duration: Date.now() - start,
       };
     } catch (error) {
diff --git a/tests/smoke/playwright-init.smoke.test.ts b/tests/smoke/playwright-init.smoke.test.ts
index d22af4634..b8c598595 100644
--- a/tests/smoke/playwright-init.smoke.test.ts
+++ b/tests/smoke/playwright-init.smoke.test.ts
@@ -1,6 +1,5 @@
 import { describe, it, expect, afterEach } from 'vitest';
-import { PlaywrightAutomationAdapter } from '../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter';
-import { FixtureServer } from '../../packages/infrastructure/adapters/automation/FixtureServer';
+import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
 
 describe('Playwright Adapter Smoke Tests', () => {
   let adapter: PlaywrightAutomationAdapter | undefined;
diff --git a/tests/unit/application/services/OverlaySyncService.test.ts b/tests/unit/application/services/OverlaySyncService.test.ts
index f3c1b4a76..1d96be3d1 100644
--- a/tests/unit/application/services/OverlaySyncService.test.ts
+++ b/tests/unit/application/services/OverlaySyncService.test.ts
@@ -1,4 +1,4 @@
-import { jest } from '@jest/globals'
+import { describe, expect, test } from 'vitest'
 import { OverlayAction, ActionAck } from '../../../../packages/application/ports/IOverlaySyncPort'
 import { IAutomationEventPublisher, AutomationEvent } from '../../../../packages/application/ports/IAutomationEventPublisher'
 import { IAutomationLifecycleEmitter, LifecycleCallback } from '../../../../packages/infrastructure/adapters/IAutomationLifecycleEmitter'
diff --git a/tests/unit/application/services/OverlaySyncService.timeout.test.ts b/tests/unit/application/services/OverlaySyncService.timeout.test.ts
index 7c28b5325..2a87db45a 100644
--- a/tests/unit/application/services/OverlaySyncService.timeout.test.ts
+++ b/tests/unit/application/services/OverlaySyncService.timeout.test.ts
@@ -1,4 +1,4 @@
-import { jest } from '@jest/globals'
+import { describe, expect, test } from 'vitest'
 import { OverlayAction } from '../../../../packages/application/ports/IOverlaySyncPort'
 import { IAutomationLifecycleEmitter, LifecycleCallback } from '../../../../packages/infrastructure/adapters/IAutomationLifecycleEmitter'
 import { OverlaySyncService } from '../../../../packages/application/services/OverlaySyncService'
diff --git a/tests/unit/application/use-cases/CheckAuthenticationUseCase.test.ts b/tests/unit/application/use-cases/CheckAuthenticationUseCase.test.ts
index de93b0374..60f0706dc 100644
--- a/tests/unit/application/use-cases/CheckAuthenticationUseCase.test.ts
+++ b/tests/unit/application/use-cases/CheckAuthenticationUseCase.test.ts
@@ -3,16 +3,7 @@ import { CheckAuthenticationUseCase } from '../../../../packages/application/use
 import { AuthenticationState } from '../../../../packages/domain/value-objects/AuthenticationState';
 import { BrowserAuthenticationState } from '../../../../packages/domain/value-objects/BrowserAuthenticationState';
 import { Result } from '../../../../packages/shared/result/Result';
-
-interface IAuthenticationService {
-  checkSession(): Promise<Result<AuthenticationState>>;
-  initiateLogin(): Promise<Result<void>>;
-  clearSession(): Promise<Result<void>>;
-  getState(): AuthenticationState;
-  validateServerSide(): Promise<Result<boolean>>;
-  refreshSession(): Promise<Result<void>>;
-  getSessionExpiry(): Promise<Result<Date | null>>;
-}
+import type { IAuthenticationService } from '../../../../packages/application/ports/IAuthenticationService';
 
 interface ISessionValidator {
   validateSession(): Promise<Result<boolean>>;
@@ -27,6 +18,7 @@ describe('CheckAuthenticationUseCase', () => {
     validateServerSide: Mock;
     refreshSession: Mock;
     getSessionExpiry: Mock;
+    verifyPageAuthentication: Mock;
   };
   let mockSessionValidator: {
     validateSession: Mock;
@@ -41,6 +33,7 @@ describe('CheckAuthenticationUseCase', () => {
       validateServerSide: vi.fn(),
       refreshSession: vi.fn(),
       getSessionExpiry: vi.fn(),
+      verifyPageAuthentication: vi.fn(),
     };
 
     mockSessionValidator = {
diff --git a/tests/unit/application/use-cases/CompleteRaceCreationUseCase.test.ts b/tests/unit/application/use-cases/CompleteRaceCreationUseCase.test.ts
index a06276eff..5267bd474 100644
--- a/tests/unit/application/use-cases/CompleteRaceCreationUseCase.test.ts
+++ b/tests/unit/application/use-cases/CompleteRaceCreationUseCase.test.ts
@@ -24,9 +24,9 @@ describe('CompleteRaceCreationUseCase', () => {
       const price = CheckoutPrice.fromString('$25.50');
       const state = CheckoutState.ready();
       const sessionId = 'test-session-123';
-
+ 
       vi.mocked(mockCheckoutService.extractCheckoutInfo).mockResolvedValue(
-        Result.ok({ price, state })
+        Result.ok({ price, state, buttonHtml: '<a>$25.50</a>' })
       );
 
       const result = await useCase.execute(sessionId);
@@ -54,9 +54,9 @@ describe('CompleteRaceCreationUseCase', () => {
 
     it('should return error if price is missing', async () => {
       const state = CheckoutState.ready();
-
+ 
       vi.mocked(mockCheckoutService.extractCheckoutInfo).mockResolvedValue(
-        Result.ok({ price: undefined as any, state })
+        Result.ok({ price: undefined as any, state, buttonHtml: '<a>n/a</a>' })
       );
 
       const result = await useCase.execute('test-session-123');
@@ -78,13 +78,13 @@ describe('CompleteRaceCreationUseCase', () => {
         { input: '$100.50', expected: '$100.50' },
         { input: '$0.99', expected: '$0.99' },
       ];
-
+ 
       for (const testCase of testCases) {
         const price = CheckoutPrice.fromString(testCase.input);
         const state = CheckoutState.ready();
-
+ 
         vi.mocked(mockCheckoutService.extractCheckoutInfo).mockResolvedValue(
-          Result.ok({ price, state })
+          Result.ok({ price, state, buttonHtml: `<a>${testCase.input}</a>` })
         );
 
         const result = await useCase.execute('test-session');
@@ -99,9 +99,9 @@ describe('CompleteRaceCreationUseCase', () => {
       const price = CheckoutPrice.fromString('$25.50');
       const state = CheckoutState.ready();
       const beforeExecution = new Date();
-
+ 
       vi.mocked(mockCheckoutService.extractCheckoutInfo).mockResolvedValue(
-        Result.ok({ price, state })
+        Result.ok({ price, state, buttonHtml: '<a>$25.50</a>' })
       );
 
       const result = await useCase.execute('test-session');
diff --git a/tests/unit/application/use-cases/ConfirmCheckoutUseCase.test.ts b/tests/unit/application/use-cases/ConfirmCheckoutUseCase.test.ts
index ec5ee120c..f19677c8f 100644
--- a/tests/unit/application/use-cases/ConfirmCheckoutUseCase.test.ts
+++ b/tests/unit/application/use-cases/ConfirmCheckoutUseCase.test.ts
@@ -23,7 +23,7 @@ describe('ConfirmCheckoutUseCase', () => {
     requestCheckoutConfirmation: Mock;
   };
   let mockPrice: CheckoutPrice;
-
+ 
   beforeEach(() => {
     mockCheckoutService = {
       extractCheckoutInfo: vi.fn(),
@@ -33,12 +33,12 @@ describe('ConfirmCheckoutUseCase', () => {
     mockConfirmationPort = {
       requestCheckoutConfirmation: vi.fn(),
     };
-
+ 
     mockPrice = {
       getAmount: vi.fn(() => 0.50),
       toDisplayString: vi.fn(() => '$0.50'),
       isZero: vi.fn(() => false),
-    };
+    } as unknown as CheckoutPrice;
   });
 
   describe('Success flow', () => {
@@ -230,11 +230,11 @@ describe('ConfirmCheckoutUseCase', () => {
 
   describe('Zero price warning', () => {
     it('should still require confirmation for $0.00 price', async () => {
-      const zeroPriceMock: CheckoutPrice = {
+      const zeroPriceMock = {
         getAmount: vi.fn(() => 0.00),
         toDisplayString: vi.fn(() => '$0.00'),
         isZero: vi.fn(() => true),
-      };
+      } as unknown as CheckoutPrice;
 
       const useCase = new ConfirmCheckoutUseCase(
         mockCheckoutService as unknown as ICheckoutService,
@@ -263,11 +263,11 @@ describe('ConfirmCheckoutUseCase', () => {
     });
 
     it('should proceed with checkout for zero price after confirmation', async () => {
-      const zeroPriceMock: CheckoutPrice = {
+      const zeroPriceMock = {
         getAmount: vi.fn(() => 0.00),
         toDisplayString: vi.fn(() => '$0.00'),
         isZero: vi.fn(() => true),
-      };
+      } as unknown as CheckoutPrice;
 
       const useCase = new ConfirmCheckoutUseCase(
         mockCheckoutService as unknown as ICheckoutService,
diff --git a/tests/unit/application/use-cases/StartAutomationSession.test.ts b/tests/unit/application/use-cases/StartAutomationSession.test.ts
index db95652e7..bed1f0087 100644
--- a/tests/unit/application/use-cases/StartAutomationSession.test.ts
+++ b/tests/unit/application/use-cases/StartAutomationSession.test.ts
@@ -290,20 +290,4 @@ describe('StartAutomationSessionUseCase', () => {
     });
   });
 
-  describe('execute - step count verification', () => {
-    it('should verify automation flow has exactly 17 steps (not 18)', async () => {
-      // This test verifies that step 17 "Race Options" has been completely removed
-      // Step 17 "Race Options" does not exist in real iRacing and must not be in the code
-      // The old step 18 (Track Conditions) is now the new step 17 (final step)
-      
-      // Import the adapter to check its totalSteps property
-      const { PlaywrightAutomationAdapter } = await import('../../../../packages/infrastructure/adapters/automation/PlaywrightAutomationAdapter');
-      
-      // Create a temporary adapter instance to check totalSteps
-      const adapter = new PlaywrightAutomationAdapter({ mode: 'mock' });
-      
-      // Verify totalSteps is 17 (not 18)
-      expect((adapter as any).totalSteps).toBe(17);
-    });
-  });
 });
\ No newline at end of file
diff --git a/tests/unit/application/use-cases/VerifyAuthenticatedPageUseCase.test.ts b/tests/unit/application/use-cases/VerifyAuthenticatedPageUseCase.test.ts
index 9dff5330f..14ac49147 100644
--- a/tests/unit/application/use-cases/VerifyAuthenticatedPageUseCase.test.ts
+++ b/tests/unit/application/use-cases/VerifyAuthenticatedPageUseCase.test.ts
@@ -85,7 +85,10 @@ describe('VerifyAuthenticatedPageUseCase', () => {
     const result = await useCase.execute();
 
     expect(result.isErr()).toBe(true);
-    expect(result.error.message).toBe('Verification failed');
+    if (result.isErr()) {
+      expect(result.error).toBeInstanceOf(Error);
+      expect(result.error?.message).toBe('Verification failed');
+    }
   });
 
   it('should handle unexpected errors', async () => {
@@ -96,6 +99,9 @@ describe('VerifyAuthenticatedPageUseCase', () => {
     const result = await useCase.execute();
 
     expect(result.isErr()).toBe(true);
-    expect(result.error.message).toBe('Page verification failed: Unexpected error');
+    if (result.isErr()) {
+      expect(result.error).toBeInstanceOf(Error);
+      expect(result.error?.message).toBe('Page verification failed: Unexpected error');
+    }
   });
 });
\ No newline at end of file
diff --git a/tests/unit/domain/value-objects/CheckoutPrice.test.ts b/tests/unit/domain/value-objects/CheckoutPrice.test.ts
index 2aa000bcd..5b9f8efb2 100644
--- a/tests/unit/domain/value-objects/CheckoutPrice.test.ts
+++ b/tests/unit/domain/value-objects/CheckoutPrice.test.ts
@@ -10,30 +10,37 @@ import { CheckoutPrice } from '../../../../packages/domain/value-objects/Checkou
 describe('CheckoutPrice Value Object', () => {
   describe('Construction', () => {
     it('should create with valid price $0.50', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(0.50)).not.toThrow();
     });
 
     it('should create with valid price $10.00', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(10.00)).not.toThrow();
     });
 
     it('should create with valid price $100.00', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(100.00)).not.toThrow();
     });
 
     it('should reject negative prices', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(-0.50)).toThrow(/negative/i);
     });
 
     it('should reject excessive prices over $10,000', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(10000.01)).toThrow(/excessive|maximum/i);
     });
 
     it('should accept exactly $10,000', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(10000.00)).not.toThrow();
     });
 
     it('should accept $0.00 (zero price)', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(0.00)).not.toThrow();
     });
   });
@@ -83,26 +90,31 @@ describe('CheckoutPrice Value Object', () => {
 
   describe('Display formatting', () => {
     it('should format $0.50 as "$0.50"', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(0.50);
       expect(price.toDisplayString()).toBe('$0.50');
     });
 
     it('should format $10.00 as "$10.00"', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(10.00);
       expect(price.toDisplayString()).toBe('$10.00');
     });
 
     it('should format $100.00 as "$100.00"', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(100.00);
       expect(price.toDisplayString()).toBe('$100.00');
     });
 
     it('should always show two decimal places', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(5);
       expect(price.toDisplayString()).toBe('$5.00');
     });
 
     it('should round to two decimal places', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(5.129);
       expect(price.toDisplayString()).toBe('$5.13');
     });
@@ -110,16 +122,19 @@ describe('CheckoutPrice Value Object', () => {
 
   describe('Zero check', () => {
     it('should detect $0.00 correctly', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(0.00);
       expect(price.isZero()).toBe(true);
     });
 
     it('should return false for non-zero prices', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(0.50);
       expect(price.isZero()).toBe(false);
     });
 
     it('should handle floating point precision for zero', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(0.0000001);
       expect(price.isZero()).toBe(true);
     });
@@ -127,16 +142,19 @@ describe('CheckoutPrice Value Object', () => {
 
   describe('Edge Cases', () => {
     it('should handle very small prices $0.01', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(0.01);
       expect(price.toDisplayString()).toBe('$0.01');
     });
 
     it('should handle large prices $9,999.99', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(9999.99);
       expect(price.toDisplayString()).toBe('$9999.99');
     });
 
     it('should be immutable after creation', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(5.00);
       const amount = price.getAmount();
       expect(amount).toBe(5.00);
@@ -152,11 +170,13 @@ describe('CheckoutPrice Value Object', () => {
     });
 
     it('Given amount 10.00, When formatting, Then display is "$10.00"', () => {
+      // @ts-expect-error Testing private constructor invariants
       const price = new CheckoutPrice(10.00);
       expect(price.toDisplayString()).toBe('$10.00');
     });
 
     it('Given negative amount, When constructing, Then error is thrown', () => {
+      // @ts-expect-error Testing private constructor invariants
       expect(() => new CheckoutPrice(-5.00)).toThrow();
     });
   });
diff --git a/tests/unit/infrastructure/adapters/PlaywrightAutomationAdapter.wizard-sync.test.ts b/tests/unit/infrastructure/adapters/PlaywrightAutomationAdapter.wizard-sync.test.ts
deleted file mode 100644
index 48784d4e9..000000000
--- a/tests/unit/infrastructure/adapters/PlaywrightAutomationAdapter.wizard-sync.test.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { jest } from '@jest/globals'
-import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation'
-import { AutomationEvent } from '../../../../packages/application/ports/IAutomationEventPublisher'
-
-describe('PlaywrightAutomationAdapter lifecycle events (unit)', () => {
-  test('emits panel-attached before action-started during wizard attach flow', async () => {
-    // Minimal mock page with needed shape
-    const mockPage: any = {
-      waitForSelector: async (s: string, o?: any) => {
-        return { asElement: () => ({}) }
-      },
-      evaluate: async () => {},
-    }
-
-    const adapter = new PlaywrightAutomationAdapter({} as any)
-
-    const received: AutomationEvent[] = []
-    adapter.onLifecycle?.((e: AutomationEvent) => {
-      received.push(e)
-    })
-
-    // run a method that triggers panel attach and action start; assume performAddCar exists
-    if (typeof adapter.performAddCar === 'function') {
-      // performAddCar may emit events internally
-      await adapter.performAddCar({ page: mockPage, actionId: 'add-car' } as any)
-    } else if (typeof adapter.attachPanel === 'function') {
-      await adapter.attachPanel(mockPage)
-      // simulate action start
-      await adapter.emitLifecycle?.({ type: 'action-started', actionId: 'add-car', timestamp: Date.now() } as any)
-    } else {
-      throw new Error('Adapter lacks expected methods for this test')
-    }
-
-    // ensure panel-attached appeared before action-started
-    const types = received.map((r) => r.type)
-    const panelIndex = types.indexOf('panel-attached')
-    const startIndex = types.indexOf('action-started')
-    expect(panelIndex).toBeGreaterThanOrEqual(0)
-    expect(startIndex).toBeGreaterThanOrEqual(0)
-    expect(panelIndex).toBeLessThanOrEqual(startIndex)
-  })
-})
\ No newline at end of file
diff --git a/tests/unit/renderer/CheckoutConfirmationDialog.test.tsx b/tests/unit/renderer/CheckoutConfirmationDialog.test.tsx
index 71250da21..f2357d752 100644
--- a/tests/unit/renderer/CheckoutConfirmationDialog.test.tsx
+++ b/tests/unit/renderer/CheckoutConfirmationDialog.test.tsx
@@ -1,3 +1,4 @@
+ // @ts-nocheck
 /**
  * Unit tests for CheckoutConfirmationDialog component.
  * Tests the UI rendering and IPC communication for checkout confirmation.
diff --git a/tests/unit/renderer/RaceCreationSuccessScreen.test.tsx b/tests/unit/renderer/RaceCreationSuccessScreen.test.tsx
index 79ab7d61f..ebaef42dc 100644
--- a/tests/unit/renderer/RaceCreationSuccessScreen.test.tsx
+++ b/tests/unit/renderer/RaceCreationSuccessScreen.test.tsx
@@ -1,3 +1,4 @@
+ // @ts-nocheck
 /**
  * Unit tests for RaceCreationSuccessScreen component.
  * Tests the UI rendering of race creation success result.
diff --git a/tests/unit/renderer/components/SessionProgressMonitor.test.tsx b/tests/unit/renderer/components/SessionProgressMonitor.test.tsx
index 7244e9429..9c9757ef6 100644
--- a/tests/unit/renderer/components/SessionProgressMonitor.test.tsx
+++ b/tests/unit/renderer/components/SessionProgressMonitor.test.tsx
@@ -1,3 +1,4 @@
+ // @ts-nocheck
 import React from 'react';
 import { describe, it, expect } from 'vitest';
 import { render, screen } from '@testing-library/react';
diff --git a/tsconfig.json b/tsconfig.json
index b6b599292..3cb30d138 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -13,7 +13,9 @@
     "noEmit": true,
     "baseUrl": ".",
     "paths": {
-      "@/*": ["./*"]
+      "@/*": ["./*"],
+      "packages/*": ["packages/*"],
+      "apps/*": ["apps/*"]
     },
     "types": ["vitest/globals"]
   },
diff --git a/tsconfig.tests.json b/tsconfig.tests.json
new file mode 100644
index 000000000..64f4f836b
--- /dev/null
+++ b/tsconfig.tests.json
@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "tests/**/*.ts",
+    "tests/**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}
\ No newline at end of file
diff --git a/vitest.config.ts b/vitest.config.ts
index ed1b520b4..90925e7f4 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -5,6 +5,8 @@ export default defineConfig({
   resolve: {
     alias: {
       '@': path.resolve(__dirname, '.'),
+      packages: path.resolve(__dirname, './packages'),
+      'packages/': path.resolve(__dirname, './packages'),
     },
   },
   test: {