.paul/ISSUES.md

@@ -1,135 +0,0 @@
-# Project Issues Log
-
-Enhancements and known issues discovered during execution and codebase analysis.
-
-## Open Issues
-
-### ~~ISS-001: MachineFingerprint null dereference on unusual hardware~~ ✅ CLOSED
-
-- **Closed:** 2026-05-18 (Phase 13, commit `4cd7715`)
-- **Fix applied:** `?.Value?.ToString() ?? string.Empty` on both WMI reads in `Licensing/MachineFingerprint.cs`
-
----
-
-### ISS-002: Blocking async calls at CLI boundary
-
-- **Discovered:** Codebase analysis (2026-05-18)
-- **Type:** Refactoring / Reliability
-- **Description:** 56+ `.GetAwaiter().GetResult()` calls in `Program.cs` and machine classes block the thread pool. .NET 4.7.2 supports `async Task<int> Main`. Risk of deadlock in certain SynchronizationContext scenarios.
-- **Files:** `Program.cs` (lines 90, 101, 122, 142, 166, 200, 221, 240, 262)
-- **Fix:** Refactor `Main` to `static async Task<int> Main(string[] args)`, propagate `await` throughout
-- **Impact:** Medium — currently works, but fragile; blocks async benefits
-- **Effort:** Medium (1-2 hours)
-- **Suggested phase:** Future refactor phase
-
----
-
-### ISS-003: Silent exception handlers swallow failures
-
-- **Discovered:** Codebase analysis (2026-05-18)
-- **Type:** Reliability / Observability
-- **Description:** 23 `try { ... } catch { }` blocks swallow exceptions silently. Disconnect/cleanup paths fail with no trace. Production issues become undiagnosable.
-- **Files:** `Cnc/Fanuc/FanucMachine.cs`, `Cnc/Siemens/SiemensMachine.cs`, `Cnc/Heidenhain/HeidenhainMachine.cs`, `Cnc/Heidenhain/Lsv2Client.cs`
-- **Fix:** At minimum `catch (Exception ex) { /* log or Debug.WriteLine */ }` — better with logging framework (ISS-004)
-- **Impact:** High — hidden failures, connection leaks masked
-- **Effort:** Quick-Medium (dependent on ISS-004)
-- **Suggested phase:** Same phase as ISS-004
-
----
-
-### ISS-004: No structured logging framework
-
-- **Discovered:** Codebase analysis (2026-05-18)
-- **Type:** Observability / Reliability
-- **Description:** Entire codebase uses `Console.WriteLine` (98+ calls). No log levels, no timestamps, no file output. Production issues undiagnosable without attaching a terminal.
-- **Files:** `Program.cs`, all machine implementations
-- **Fix:** Add Serilog or NLog. Replace `Console.WriteLine` with leveled logging. Add request/response tracing for FOCAS/LSV2/FTP operations.
-- **Impact:** Medium — works today, but operational burden grows with deployments
-- **Effort:** Substantial (half day+)
-- **Suggested phase:** v0.4 Operational Quality
-
----
-
-### ~~ISS-005: SHA256 crypto provider not disposed~~ ✅ CLOSED
-
-- **Closed:** 2026-05-18 (Phase 13, commit `4cd7715`)
-- **Fix applied:** `SHA256CryptoServiceProvider` wrapped in `using` block in `Licensing/LicenseValidator.cs`
-
----
-
-### ~~ISS-006: LSV2 connect timeout doesn't abort hung task~~ ✅ CLOSED
-
-- **Closed:** 2026-05-18 (Phase 13, commit `4cd7715`)
-- **Fix applied:** `_tcp.Close()` called in timeout branch of `Connect()` in `Cnc/Heidenhain/Lsv2Client.cs` — aborts pending socket task
-
----
-
-### ~~ISS-007: Integration tests use hardcoded IPs~~ ✅ CLOSED
-
-- **Closed:** 2026-05-18 (Phase 14)
-- **Fix applied:** `HardwareTestHelper.GetIpOrSkip(envVarName)` reads `HEIDENHAIN_IP` / `SIEMENS_IP` / `MITSUBISHI_IP`; `Assert.Ignore` fires when env var not set. Hardware tests `[Category("Hardware")]` skip in standard CI; stub-based tests unaffected.
-
----
-
-### ISS-008: MachineFingerprint — full license flow unverified on real hardware
-
-- **Discovered:** STATE.md deferred issues (ongoing)
-- **Partial fix:** 2026-05-18 (Phase 14) — `LicenseFile` edge-case tests added; `Validate_EmptyFingerprint_ReturnsFalse` confirms validator is safe against empty input
-- **Remaining:** Full end-to-end (WMI fingerprint → sign → deploy → validate) requires real Windows machine run with `HEIDENHAIN_IP` etc. set
-- **Type:** Testing
-- **Files:** `Licensing/MachineFingerprint.cs`, `Licensing/LicenseFile.cs`
-- **Impact:** High — license flow unverified on hardware before customer delivery
-- **Effort:** Quick — scaffold is in place; just needs real hardware
-
----
-
-### ISS-009: Heidenhain ReadActiveProgramAsync / SelectMainProgram not implemented
-
-- **Discovered:** STATE.md deferred issues (2026-05-13)
-- **Type:** Feature / Incomplete Implementation
-- **Description:** `HeidenhainMachine.ReadActiveProgramAsync()` and `SelectMainProgramAsync()` return hard-coded `CncResult.Fail("Not supported via basic LSV2")`. LSV2 may support these via additional commands not yet implemented.
-- **Files:** `Cnc/Heidenhain/HeidenhainMachine.cs`
-- **Impact:** Low — current use case requires explicit program path; feature unused
-- **Effort:** Substantial (requires LSV2 spec research + hardware testing)
-- **Suggested phase:** Heidenhain advanced features (future)
-
----
-
-### ISS-010: Siemens ReadActiveProgramAsync / SelectMainProgram not implemented
-
-- **Discovered:** STATE.md deferred issues (2026-05-13)
-- **Type:** Feature / Incomplete Implementation
-- **Description:** Same as ISS-009 for Siemens. FTP protocol may not expose active program info natively.
-- **Files:** `Cnc/Siemens/SiemensMachine.cs`
-- **Impact:** Low — current use case requires explicit program path
-- **Effort:** Substantial (requires Sinumerik FTP extension research)
-- **Suggested phase:** Siemens advanced features (future)
-
----
-
-### ISS-011: Obsolete crypto APIs (RSACryptoServiceProvider, SHA256CryptoServiceProvider)
-
-- **Discovered:** Codebase analysis (2026-05-18)
-- **Type:** Technical Debt
-- **Description:** Both classes marked obsolete in .NET 6+. Currently safe on .NET 4.7.2 (only warnings), but blocks future framework upgrade path.
-- **Files:** `Licensing/LicenseValidator.cs`
-- **Fix (when upgrading):** `RSA.Create()` + `rsa.VerifyData(data, sig, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1)` — eliminates both obsolete types
-- **Impact:** Low — no runtime impact on .NET 4.7.2
-- **Effort:** Quick (when .NET version is upgraded)
-- **Suggested phase:** Future .NET upgrade phase
-
----
-
-## Closed Issues
-
-| ID | Summary | Phase | Commit |
-|----|---------|-------|--------|
-| ISS-001 | MachineFingerprint null dereference on unusual hardware | 13 | `4cd7715` |
-| ISS-005 | SHA256 crypto provider not disposed | 13 | `4cd7715` |
-| ISS-006 | LSV2 connect timeout doesn't abort hung task | 13 | `4cd7715` |
-| ISS-007 | Integration tests use hardcoded IPs | 14 | `32f68c5` |
-
----
-
-*Last updated: 2026-05-18*
-*Sources: STATE.md deferred issues + CONCERNS.md codebase analysis*

.paul/PROJECT.md

@@ -13,9 +13,9 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 | Attribute | Value |
 |-----------|-------|
 | Type | Application |
-| Version | 0.4.0 |
-| Status | v0.4 complete |
-| Last Updated | 2026-05-18 |
+| Version | 0.2.0 |
+| Status | v0.2 complete |
+| Last Updated | 2026-05-17 |
 
 ## Requirements
 
@@ -45,17 +45,9 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 - [x] Connection leak fixed — try/finally in Scarica/Invia; CncResult.Errors surfaced on failure — Phase 11
 - [x] README.md — all 16 CLI params documented; 12 error codes with causa probabile + soluzione — Phase 12
 
-### Validated (Shipped) — v0.4 Robustness
-- [x] Null guards on WMI reads in MachineFingerprint (ISS-001) — Phase 13
-- [x] SHA256CryptoServiceProvider disposed after use (ISS-005) — Phase 13
-- [x] LSV2 connect timeout aborts hung TCP socket (ISS-006) — Phase 13
-- [x] Hardware test scaffolding — env-var-gated `[Category("Hardware")]` tests for all 3 machine types (ISS-007) — Phase 14
-- [x] LicenseFile edge-case tests (empty, whitespace, valid, nonexistent) — Phase 14
-- [x] Empty-fingerprint guard in LicenseValidator (ISS-008 partial) — Phase 14
-
 ### Planned (Next)
 - [ ] ReadActiveProgramAsync / SelectMainProgram for Heidenhain and Siemens
-- [ ] Full hardware test run on real Windows machine (ISS-008 full closure)
+- [ ] Integration test against real hardware (Heidenhain, Siemens, Mitsubishi)
 
 ### Out of Scope
 - Cloud sync
@@ -115,4 +107,4 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 
 ---
 *PROJECT.md — Updated when requirements or context change*
-*Last updated: 2026-05-18 after Phase 14 (test-hardening) — v0.4 complete*
+*Last updated: 2026-05-18 after Phase 11 (refactor) — v0.3 in progress*

.paul/ROADMAP.md

@@ -156,33 +156,4 @@ Completed: 2026-05-18
 - [x] 12-01: README complete CLI reference + error codes table
 
 ---
-
-## Milestone v0.4 — Robustness ✅
-
-**Status:** Complete
-**Phases:** 2 of 2 complete
-**Completed:** 2026-05-18
-
-| Phase | Name | Plans | Status | Completed |
-|-------|------|-------|--------|-----------|
-| 13 | robustness-fixes | 1 | ✅ Complete | 2026-05-18 |
-| 14 | test-hardening | 1 | ✅ Complete | 2026-05-18 |
-
-### Phase 13: robustness-fixes ✅
-
-**Goal:** Fix ISS-001, ISS-005, ISS-006 — null guard on MachineFingerprint WMI properties, dispose SHA256CryptoServiceProvider, fix Lsv2Client connect timeout to actually abort hung task.
-**Issues addressed:** ISS-001, ISS-005, ISS-006
-**Completed:** 2026-05-18
-**Plans:**
-- [x] 13-01: Null guard WMI, SHA256 dispose, LSV2 timeout abort
-
-### Phase 14: test-hardening ✅
-
-**Goal:** Fix ISS-007, ISS-008 — env-var-gated hardware test scaffolding for all 3 machine types; LicenseFile edge-case unit tests; empty-fingerprint guard in LicenseValidator.
-**Issues addressed:** ISS-007 (closed), ISS-008 (scaffold complete; full closure requires Windows hardware run)
-**Completed:** 2026-05-18
-**Plans:**
-- [x] 14-01: HardwareTestHelper + LicenseFileTests + Validate_EmptyFingerprint
-
----
-*Roadmap updated: 2026-05-18 — v0.4 milestone complete.*
+*Roadmap updated: 2026-05-18 — v0.3 complete.*

.paul/STATE.md

@@ -5,44 +5,30 @@
 See: .paul/PROJECT.md (updated 2026-05-18)
 
 **Core value:** Machinists transfer CNC programs to/from any controller without manual steps or internet
-**Current focus:** v0.4 complete — all milestones done
+**Current focus:** v0.3 complete — all phases done
 
 ## Current Position
 
-Milestone: v0.4 Robustness — **Complete**
-Phase: 14 of 14 (test-hardening) — Complete
-Plan: 14-01 unified
-Status: Milestone complete — ready for next milestone or release
-Last activity: 2026-05-18 — Phase 14 complete, v0.4 milestone closed
+Milestone: v0.3 Code Quality — **COMPLETE**
+Phase: 12 of 12 (docs-cli) — Complete
+Plan: 12-01 complete
+Status: All milestones complete
+Last activity: 2026-05-18 — Phase 12 (docs-cli) complete
 
 Progress:
 - Milestone v0.1: [██████████] 100% (complete)
 - Milestone v0.2: [██████████] 100% (complete)
 - Milestone v0.3: [██████████] 100% (complete)
-- Milestone v0.4: [██████████] 100% (complete)
-- Phase 13: [██████████] 100% (complete)
-- Phase 14: [██████████] 100% (complete)
+- Phase 11 (refactor): [██████████] 100% (complete)
+- Phase 12 (docs-cli): [██████████] 100% (complete)
 
 ## Loop Position
 
 ```
 PLAN ──▶ APPLY ──▶ UNIFY
-  ✓        ✓        ✓     [Loop complete — v0.4 milestone closed]
+  ✓        ✓        ✓     [Phase 12 complete — v0.3 milestone complete]
 ```
 
-## What Was Built (v0.4 Robustness — complete)
-
-### Phase 14 — Test Hardening
-- `NcProgramManager.Tests/Integration/HardwareTestHelper.cs` — `GetIpOrSkip(string)` calls `Assert.Ignore` when env var missing; ISS-007 closed
-- `HeidenhainMachineIntegrationTests.cs`, `SiemensMachineIntegrationTests.cs`, `MitsubishiMachineIntegrationTests.cs` — `Hardware_ConnectAsync_RealMachine` + `[Category("Hardware")]` added to each
-- `NcProgramManager.Tests/Unit/LicenseFileTests.cs` — 4 tests covering empty, whitespace, valid base64, nonexistent path
-- `LicenseValidatorTests.cs` — `Validate_EmptyFingerprint_ReturnsFalse` added; ISS-008 scaffold complete
-
-### Phase 13 — Robustness Fixes
-- `Licensing/MachineFingerprint.cs` — null guards on both WMI reads (`?.Value?.ToString() ?? string.Empty`); ISS-001 closed
-- `Licensing/LicenseValidator.cs` — `SHA256CryptoServiceProvider` in `using` block inside `Validate()`; ISS-005 closed
-- `Cnc/Heidenhain/Lsv2Client.cs` — `Connect()` calls `_tcp.Close()` on timeout branch to abort pending socket; ISS-006 closed
-
 ## What Was Built (v0.3 Code Quality — complete)
 
 ### Phase 11 — Refactor
@@ -150,35 +136,26 @@ PLAN ──▶ APPLY ──▶ UNIFY
 - `#` = Warning in Fanuc/Mitsubishi — macro variable indicator
 
 ### Deferred Issues
-Tracked in `.paul/ISSUES.md` — 11 issues total; 5 closed (ISS-001, ISS-005, ISS-006, ISS-007, ISS-008 partial).
-
-Key open items:
-- ISS-002: Blocking .GetAwaiter().GetResult() — Medium, refactor
-- ISS-003: Silent catch {} blocks — High, needs logging (ISS-004)
-- ISS-004: No logging framework — Medium, Substantial effort
-- ISS-008: Full closure needs real Windows hardware run with env vars set
-- ISS-009/010: Heidenhain/Siemens ReadActiveProgram not implemented — deferred
-- `private.key.xml` owned by root (external repo) — run `sudo chown $USER ~/Documents/mine/c#/LicenseGenerator/private.key.xml`
+- Heidenhain: `ReadActiveProgramAsync` / `SelectMainProgram` not implemented
+- Siemens: same as Heidenhain
+- Build + integration not verifiable on Linux (fwlib32 Windows-only)
+- MachineFingerprint WMI + full license flow — needs real Windows hardware test
+- `private.key.xml` owned by root — run `sudo chown $USER ~/Documents/mine/c#/LicenseGenerator/private.key.xml`
 
 ### Blockers/Concerns
 None — all milestones complete.
 
 ### Git State
-Last commit: `32f68c5` — feat(14-test-hardening): env-var hardware test scaffolding + LicenseFile edge cases
+Last commit: `bd17ea4` — feat(11-refactor): extract ArgParser, fix error handling, remove dead code
 LicenseGenerator repo: commit `2ef68dd` — feat: initial LicenseGenerator
-Branch: main
-
-## Codebase Mapped
-
-Date: 2026-05-18
-Documents: `.paul/codebase/` (7 files — STACK, ARCHITECTURE, STRUCTURE, CONVENTIONS, TESTING, INTEGRATIONS, CONCERNS)
+Branch: main (pushed)
 
 ## Session Continuity
 
 Last session: 2026-05-18
-Stopped at: v0.4 Robustness milestone complete — all 14 phases done
-Next action: /paul:milestone for next milestone, or review open issues (ISS-002/003/004/008)
-Resume file: .paul/phases/14-test-hardening/14-01-SUMMARY.md
+Stopped at: v0.3 complete — all phases done
+Next action: No planned phases. Start new milestone or ship.
+Resume file: .paul/ROADMAP.md
 
 ---
 *STATE.md — Updated after every significant action*

.paul/codebase/ARCHITECTURE.md

@@ -1,156 +0,0 @@
-# Architecture
-
-**Analysis Date:** 2026-05-18
-
-## Pattern Overview
-
-**Overall:** Layered CLI console application with abstract machine interface, factory dispatch, and offline license gate.
-
-**Key Characteristics:**
-- Single Windows EXE (all dependencies embedded via Costura.Fody)
-- Polymorphic multi-vendor CNC support via `ICncMachine` interface
-- Factory pattern for manufacturer selection at runtime
-- Async/await throughout (Task-based), but blocked at CLI boundary via `.GetAwaiter().GetResult()`
-- Result-wrapper pattern (`CncResult<T>`) instead of exceptions for CNC operations
-- RSA license validation gate on every startup
-
-## Layers
-
-**CLI Entry Layer:**
-- Purpose: Parse args, validate license, dispatch to action (Scarica/Invia)
-- Contains: `Program.cs` (main orchestration), `ArgParser.cs` (regex arg parsing), `InputArgs.cs` (config object)
-- Depends on: Licensing layer, CNC abstraction layer
-- Error output: Negative exit codes (-100 to -208) mapped to Italian user messages
-
-**Licensing Layer:**
-- Purpose: Prevent execution on unlicensed machines
-- Contains: `Licensing/LicenseValidator.cs`, `Licensing/MachineFingerprint.cs`, `Licensing/LicenseFile.cs`
-- Depends on: WMI (System.Management), RSA crypto
-- Used by: CLI entry layer (startup check only)
-
-**CNC Abstraction Layer:**
-- Purpose: Uniform interface over 4 different CNC protocols
-- Contains: `Cnc/ICncMachine.cs`, `Cnc/IFanucMachine.cs`, `Cnc/CncMachineFactory.cs`, `Cnc/Models/`
-- Key types: `CncResult<T>`, `CncError`, `CncManufacturer`, `ConnectionState`, `CncProgram`
-- Used by: CLI entry layer
-
-**Manufacturer Implementations:**
-- Purpose: Protocol-specific CNC communication
-- Contains: `Cnc/Fanuc/`, `Cnc/Heidenhain/`, `Cnc/Siemens/`, `Cnc/Mitsubishi/`
-- Each implements `ICncMachine` (Fanuc also implements `IFanucMachine`)
-- Depends on: Protocol libraries (FOCAS DLL, TCP socket, FtpWebRequest)
-
-**Validation Layer:**
-- Purpose: Pre-upload NC program syntax checking
-- Contains: `Cnc/INcProgramValidator.cs`, `Cnc/NcProgramValidator.cs`
-- Injected into machine implementations; upload blocked on Error severity
-- Depends on: Nothing external
-
-**NC Program Parsing:**
-- Purpose: Parse/format Fanuc composite NC file format
-- Contains: `FanucProgram.cs` (program + tooloffset + workzero sections)
-- Used by: CLI entry layer post-download
-
-## Data Flow
-
-**Scarica (Download from CNC):**
-```
-CLI args
-  → ArgParser.Parse() → InputArgs
-  → LicenseValidator.Validate() [exit -1xx on failure]
-  → CncMachineFactory.Create(InputArgs) → ICncMachine
-  → machine.ConnectAsync() → CncResult<bool>
-  → machine.ReadProgramAsync(path) → CncResult<string>
-  → [IFanucMachine cast] ReadToolDataAsync / ReadWorkZeroDataAsync
-  → FanucProgram.Format() → composite file string
-  → File.WriteAllText(localPath)
-```
-
-**Invia (Upload to CNC):**
-```
-CLI args
-  → ArgParser.Parse() → InputArgs
-  → LicenseValidator.Validate() [exit -1xx on failure]
-  → CncMachineFactory.Create(InputArgs) → ICncMachine
-  → File.ReadAllText(localPath)
-  → NcProgramValidator.Validate() [exit on Error severity]
-  → machine.ConnectAsync()
-  → machine.WriteProgramAsync(path, content) → CncResult<bool>
-```
-
-**State Management:**
-- No persistent in-memory state between invocations (each run is independent)
-- Machine state tracked per-instance: `ConnectionState` enum + `StateChanged` event
-- Thread safety: `SemaphoreSlim` gate per machine instance
-
-## Key Abstractions
-
-**ICncMachine:**
-- Purpose: Uniform contract for all CNC machines
-- Location: `Cnc/ICncMachine.cs`
-- Methods: `ConnectAsync`, `DisconnectAsync`, `ReadProgramAsync`, `WriteProgramAsync`, `ReadAsync`, `DeleteProgramAsync`, `ReadActiveProgramAsync`, `SelectMainProgramAsync`
-- Pattern: Interface + factory dispatch
-
-**IFanucMachine:**
-- Purpose: Fanuc-specific extensions (tool offsets, work zero)
-- Location: `Cnc/IFanucMachine.cs`
-- Extends: `ICncMachine`
-- Pattern: Interface specialization
-
-**CncResult<T>:**
-- Purpose: Typed result wrapper replaces exception-based control flow
-- Location: `Cnc/Models/CncResult.cs`
-- Factories: `Ok()`, `Fail()`, `Cancelled()`, `OkWithWarnings()`
-- Properties: `Success`, `Errors`, `WasCancelled`, `Value`
-
-**IFocasDialect:**
-- Purpose: Abstract FOCAS version differences (Legacy vs Modern API)
-- Location: `Cnc/Fanuc/IFocasDialect.cs`
-- Implementations: `LegacyFocasDialect.cs`, `ModernFocasDialect.cs`
-- Detection: `FanucDialectDetector.cs` at connect time
-
-**CncMachineFactory:**
-- Purpose: Create correct ICncMachine from InputArgs
-- Location: `Cnc/CncMachineFactory.cs`
-- Dispatches on: `CncManufacturer` enum (Fanuc, Heidenhain, Siemens, Mitsubishi)
-
-## Entry Points
-
-**CLI Entry:**
-- Location: `Program.cs` (Main method)
-- Triggers: Process execution from command line or calling application
-- Responsibilities: Arg parsing → license check → machine factory → action dispatch → exit code
-
-**Argument Parser:**
-- Location: `ArgParser.cs` (static `Parse(string[])`)
-- Returns: `InputArgs` with all 16 CLI parameters normalized
-
-## Error Handling
-
-**Strategy:** Result wrapper at CNC layer, exit codes at CLI boundary, ArgumentNullException for null guards
-
-**Patterns:**
-- `CncResult<T>.Fail(errors)` for CNC operation failures
-- `ArgumentNullException` for constructor null guards (`Cnc/Fanuc/FanucMachine.cs`)
-- Exit codes -100 to -208 in `Program.cs` for user-facing errors
-- `try/finally` with `connected` flag for connection leak prevention (`Program.cs`)
-- `catch { }` (silent) on disconnect cleanup paths — known weakness (see CONCERNS.md)
-
-## Cross-Cutting Concerns
-
-**Logging:**
-- `Console.WriteLine` only — no structured logging framework
-- Debug mode (`-debug=` arg): keeps terminal open after operation
-
-**Validation:**
-- `NcProgramValidator` injected into machine constructors
-- Runs before upload; blocked on `ValidationSeverity.Error`
-
-**Cancellation:**
-- `CancellationToken` passed through all async methods
-- CLI does not currently expose cancellation to user
-
----
-
-*Architecture analysis: 2026-05-18*
-*Update when major patterns change*

.paul/codebase/CONCERNS.md

@@ -1,152 +0,0 @@
-# Codebase Concerns
-
-**Analysis Date:** 2026-05-18
-
-## Tech Debt
-
-**Blocking async calls at CLI boundary:**
-- Issue: 56+ `.GetAwaiter().GetResult()` calls block async operations synchronously
-- Files: `Program.cs` (lines 90, 101, 122, 142, 166, 200, 221, 240, 262), machine classes
-- Why: Main() was not async when initially written; .NET 4.7.2 supports async Main via C# 7.1
-- Impact: Thread pool starvation risk, deadlock risk in certain SynchronizationContext scenarios, harder debugging
-- Fix: Refactor `Program.Main` to `static async Task<int> Main(string[] args)`, propagate `await` throughout
-
-**Silent exception handlers (catch without logging):**
-- Issue: `try { ... } catch { }` swallows exceptions with no trace
-- Files: `Cnc/Fanuc/FanucMachine.cs` (disconnect cleanup), `Cnc/Siemens/SiemensMachine.cs`, `Cnc/Heidenhain/HeidenhainMachine.cs`, `Cnc/Heidenhain/Lsv2Client.cs`
-- Why: Cleanup paths (disconnect, logout) should not propagate to caller; silence was intentional
-- Impact: Resource leaks masked, production issues undiagnosable, disconnect failures invisible
-- Fix: Log at minimum to debug/trace: `catch (Exception ex) { /* log ex */ }`. Add logging framework.
-
-**No structured logging framework:**
-- Issue: Entire codebase uses `Console.WriteLine` (98+ calls in `Program.cs` alone)
-- Files: `Program.cs`, all machine implementations
-- Why: MVP simplicity; tool was always a CLI
-- Impact: No log levels, no timestamps, no file logging, production issues undiagnosable
-- Fix: Add Serilog or NLog. Replace Console.WriteLine with `_logger.Information()`. Add request/response tracing to FOCAS calls.
-
-**Large monolithic FanucMachine:**
-- Issue: `Cnc/Fanuc/FanucMachine.cs` is ~740 lines with complex state management
-- Files: `Cnc/Fanuc/FanucMachine.cs`
-- Why: FOCAS protocol has many edge cases; chunked transfer and offset handling grew organically
-- Impact: Hard to test individual branches; buffer handling edge cases unclear
-- Fix: Extract `IFocasTransferHandler` for chunk upload/download logic; separate offset data reader
-
-**`string.Format()` over `$""` interpolation:**
-- Issue: Old string formatting style throughout validator and some machine code
-- Files: `Cnc/NcProgramValidator.cs`, `Program.cs`
-- Why: Legacy code predates C# 6 adoption on this project
-- Impact: Cosmetic; harder to read format strings
-- Fix: Opportunistic migration to `$""` during edits
-
-## Known Issues / Incomplete Implementations
-
-**Heidenhain ReadActiveProgramAsync / SelectMainProgram not implemented:**
-- Symptoms: Returns `CncResult.Fail("Not supported via basic LSV2")`
-- Files: `Cnc/Heidenhain/HeidenhainMachine.cs`
-- Root cause: LSV2 protocol complexity; feature not required for initial release
-- Workaround: Users specify program path explicitly
-
-**Siemens ReadActiveProgramAsync / SelectMainProgram not implemented:**
-- Symptoms: Returns stub failure
-- Files: `Cnc/Siemens/SiemensMachine.cs`
-- Root cause: FTP protocol doesn't expose active program info
-- Workaround: Users specify program path explicitly
-
-**MachineSnapshot returns stub data for Heidenhain/Siemens/Mitsubishi:**
-- Files: `Cnc/Heidenhain/HeidenhainMachine.cs`, `Cnc/Siemens/SiemensMachine.cs`, `Cnc/Mitsubishi/MitsubishiMachine.cs`
-- Issue: All snapshot fields return Unknown/empty; no real machine state read
-- Impact: No diagnostic info available for non-Fanuc machines
-
-## Security Considerations
-
-**RSA public key hardcoded in binary:**
-- Risk: Key embedded as const string in binary; cannot be rotated without recompile and redeploy
-- Files: `Licensing/LicenseValidator.cs`
-- Current mitigation: Asymmetric RSA — private key is vendor-only; hardcoded public key is acceptable for this use case
-- Recommendation: Document key rotation procedure; consider adding license version/expiration metadata for future revocation
-
-**MachineFingerprint null dereference on unusual hardware:**
-- Risk: `mo.Properties["processorID"].Value.ToString()` throws NullReferenceException if WMI property missing
-- Files: `Licensing/MachineFingerprint.cs`
-- Current mitigation: None
-- Fix: `mo.Properties["processorID"]?.Value?.ToString() ?? "unknown"`
-
-**Obsolete crypto APIs:**
-- Risk: `RSACryptoServiceProvider` and `SHA256CryptoServiceProvider` are obsolete in .NET 6+
-- Files: `Licensing/LicenseValidator.cs`
-- Current mitigation: .NET 4.7.2 target — obsolete warning only, not broken
-- Fix when upgrading: Use `RSA.Create()` + `VerifyData(data, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1)`
-
-**SHA256 provider not explicitly disposed:**
-- Risk: Minor resource leak in license validation path
-- Files: `Licensing/LicenseValidator.cs`
-- Fix: Wrap in `using (var sha = new SHA256CryptoServiceProvider()) { ... }`
-
-## Platform Constraints
-
-**Windows-only (hard constraint):**
-- FOCAS1 DLL (`Fwlib32.dll`) is 32-bit Windows native — no Linux/macOS support
-- WMI (`System.Management`) Windows-only — licensing system non-functional on Linux
-- Files: `Cnc/Fanuc/libs/`, `Licensing/MachineFingerprint.cs`, `fwlib32.cs`
-- Impact: Cannot run on Linux/macOS; CI on Linux can only test non-FOCAS paths
-- Action if cross-platform needed: Abstract fingerprinting behind `IMachineFingerprint`; already done — add Linux implementation using `/proc/cpuinfo` or `dmidecode`
-
-**FOCAS DLL version sensitivity:**
-- Risk: FOCAS API changes between Fanuc control versions; `FanucDialectDetector` auto-detects but may fail on unknown versions
-- Files: `Cnc/Fanuc/FanucDialectDetector.cs`, `Cnc/Fanuc/FanucMachine.cs`
-- Mitigation: Dialect abstraction layer (`IFocasDialect`) isolates version differences
-
-## Performance Bottlenecks
-
-**In-memory accumulation for large NC programs:**
-- Issue: `UploadProgramByIdentifier` appends to `StringBuilder` for entire program before writing
-- Files: `Cnc/Fanuc/FanucMachine.cs`
-- Impact: For programs >10MB, high memory allocation; streaming to file would be more efficient
-- Fix: Write chunks directly to `FileStream` instead of accumulating in memory
-
-**Polling with 100ms busy-wait during transfer:**
-- Issue: `ct.WaitHandle.WaitOne(100)` loops during buffer waits
-- Files: `Cnc/Fanuc/FanucMachine.cs`
-- Impact: Wastes thread-pool slot; CPU cycles during transfer
-- Fix: Use `await Task.Delay(100, ct)` instead of blocking WaitOne
-
-**Network connection timeout via `.Wait()` with boolean return:**
-- Issue: `_tcp.ConnectAsync().Wait(timeout)` — if task never completes, does not abort it
-- Files: `Cnc/Heidenhain/Lsv2Client.cs`
-- Fix: `await Task.WhenAny(connectTask, Task.Delay(timeout, ct))` + cancellation
-
-## Fragile Areas
-
-**FOCAS dialect detection (`FanucDialectDetector`):**
-- Files: `Cnc/Fanuc/FanucDialectDetector.cs`
-- Why fragile: Relies on probing specific FOCAS API calls to detect version; untested against full range of Fanuc control generations
-- Safe modification: Always test against physical hardware after changes; log detected dialect version
-
-**License validation (no recovery path):**
-- Files: `Licensing/LicenseValidator.cs`, `Licensing/MachineFingerprint.cs`
-- Why fragile: Any WMI failure or file read error produces a hard exit with no diagnostic for user
-- Safe modification: Add exception handling with user-facing error message; distinguish "no license file" from "invalid license" from "fingerprint failure"
-
-**Integration tests with hardcoded IPs:**
-- Files: `NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs`, `HeidenhainMachineIntegrationTests.cs`, `MitsubishiMachineIntegrationTests.cs`
-- Why fragile: Tests will fail in CI without physical hardware at specific IPs
-- Fix: Make IPs configurable via environment variables; skip integration tests in CI by default
-
-## Missing / Not Covered
-
-- No CLI-level tests (no test for `Program.cs` orchestration or exit code behavior)
-- No tests for `MachineFingerprint` (WMI, no mock tests)
-- No tests for `LicenseFile` parsing edge cases (corrupt Base64, empty file)
-- No structured logging or diagnostics framework
-- No error code documentation in code (only in `README.md`)
-- No architecture documentation (FOCAS dialect selection logic undocumented in code)
-
----
-
-**Overall Assessment:** Architecture is solid — clean machine abstraction, well-structured interfaces, good error propagation via `CncResult<T>`. Main concerns are operational (logging, blocking async, empty catch blocks) rather than structural. Platform constraints (Windows, FOCAS DLL) are intentional for the target environment.
-
----
-
-*Concerns analysis: 2026-05-18*
-*Update as issues are resolved or discovered*

.paul/codebase/CONVENTIONS.md

@@ -1,122 +0,0 @@
-# Coding Conventions
-
-**Analysis Date:** 2026-05-18
-
-## Naming Patterns
-
-**Files:**
-- PascalCase for all `.cs` files: `FanucMachine.cs`, `CncResult.cs`
-- Interfaces: I-prefix PascalCase: `ICncMachine.cs`, `IFocasDialect.cs`
-- Tests: `{Subject}Tests.cs` or `{Subject}IntegrationTests.cs`
-- Config classes: `{Manufacturer}ConnectionConfig.cs`
-
-**Classes:**
-- PascalCase for all classes
-- Sealed preferred for implementations (not open to inheritance)
-  - Examples: `NcProgramValidator.cs`, `CncResult.cs`
-- Manufacturer-prefixed where relevant: `FanucMachine`, `HeidenhainMachine`, `SiemensMachine`
-
-**Interfaces:**
-- I-prefix strictly followed: `ICncMachine`, `IFanucMachine`, `ILicenseValidator`, `IFocasDialect`
-
-**Fields:**
-- Private: `_camelCase` with underscore prefix
-  - Example: `_config`, `_validator`, `_state`, `_hndl` in `Cnc/Fanuc/FanucMachine.cs`
-- Constants (public): PascalCase — `AlarmSlots`, `TransferChunkSize` in `Cnc/Fanuc/FanucMachine.cs`
-- Constants (private): can be UPPER_CASE or PascalCase
-- Static readonly: `_camelCase` with underscore
-
-**Properties:**
-- PascalCase, read-only preferred
-  - Example: `Name`, `Comment`, `Content`, `Path` in `Cnc/Models/CncProgram.cs`
-
-**Methods:**
-- PascalCase for all public methods: `ConnectAsync()`, `ReadProgramAsync()`
-- `Async` suffix on all methods returning `Task<T>` or `Task`
-- Private helpers: `PascalCase` (same as public, no underscore)
-  - Example: `NcProgramValidator.cs`
-
-**Enums:**
-- PascalCase for type name, PascalCase for values
-  - Examples: `CncManufacturer.Fanuc`, `ConnectionState.Connected`, `FanucTransport.Ethernet`
-
-## Code Style
-
-**Formatting:**
-- 4-space indentation
-- Allman brace style (opening brace on new line for classes and methods)
-  - Example: `Cnc/Fanuc/FanucMachine.cs`
-- Single-line property getters: inline `{ get { return _x; } }`
-- No `.editorconfig` or StyleCop — conventions enforced by practice
-
-**String Formatting:**
-- `string.Format()` for parameterized messages (not `$""` interpolation)
-  - Example: `Cnc/NcProgramValidator.cs` lines with format strings
-- `+` concatenation for console output in `Program.cs`
-
-**Async:**
-- `default` parameter for `CancellationToken` on async methods
-- `ConfigureAwait(false)` on library-level code
-- `Task.Run()` for blocking FOCAS calls in async context (RunGuardedAsync pattern)
-
-## Import Organization
-
-**Order:**
-1. System namespaces
-2. External packages
-3. Internal project namespaces
-
-No path aliases (not applicable to .NET Framework / no source generators).
-
-## Error Handling
-
-**Patterns:**
-- Null guards at constructor: `if (config == null) throw new ArgumentNullException("config")`
-  - Example: `Cnc/Fanuc/FanucMachine.cs`
-- Null-coalescing for optional deps: `_validator = validator ?? new NcProgramValidator(...)`
-- `CncResult<T>` wrapper for all CNC operations (not exceptions)
-- Exit codes at CLI boundary: -100 to -208 in `Program.cs`
-- `try/finally` with `connected` flag for connection cleanup in `Program.cs`
-
-**Result Wrapper Factories:**
-- `CncResult<T>.Ok(value)` — success
-- `CncResult<T>.Fail(errors)` — failure with error list
-- `CncResult<T>.Cancelled()` — cancellation
-- `CncResult<T>.OkWithWarnings(value, errors)` — partial success
-
-## Logging
-
-**Framework:** None — `Console.WriteLine` only
-
-**Patterns:**
-- User-facing output: `Console.WriteLine()` in `Program.cs`
-- Error output: same Console (no stderr separation)
-- No log levels, no timestamps, no structured logging
-- Debug mode via `-debug=` arg keeps terminal open post-operation
-
-## Comments
-
-**When to Comment:**
-- Document intent/constraints, not obvious code
-  - Example: `NcProgramValidator.cs` — "Name-format check (uses just the bare filename without path)"
-- Separator line style for section breaks: `// ── private helpers ─────────────────`
-  - Example: `NcProgramValidator.cs`
-
-**XML Doc Comments:**
-- Sparse; only on public classes and key methods
-- Format: `/// <summary>Brief description.</summary>`
-  - Examples: `NcProgramValidator.cs`, `CncResult.cs`, `ValidationResult.cs`
-
-**No TODO/FIXME comments found in codebase** — known deferred work tracked in STATE.md.
-
-## Function Design
-
-- Private async methods wrap blocking/mixed code with semaphore locking (RunGuardedAsync pattern)
-  - Example: `Cnc/Fanuc/FanucMachine.cs` RunGuardedAsync
-- Large transfer methods split into chunked helpers (`TransferChunked`, `UploadProgramByIdentifier`)
-- Interface/implementation pairs for all protocol clients (I-prefix interface + concrete)
-
----
-
-*Conventions analysis: 2026-05-18*
-*Update when style decisions change*

.paul/codebase/INTEGRATIONS.md

@@ -1,87 +0,0 @@
-# External Integrations
-
-**Analysis Date:** 2026-05-18
-
-## CNC Machine Protocols
-
-**Fanuc FOCAS1/FOCAS2 (proprietary):**
-- Used for: Program upload/download, tool data, work zero offset, machine state
-- SDK/Client: `fwlib32.cs` (11,569 lines, P/Invoke wrapper, Fanuc copyright 2002-2014)
-- Native DLLs: `Cnc/Fanuc/libs/Fwlib32.dll`, `fwlibe1.dll`, `fwlibNCG.dll`
-- Transport: Ethernet TCP (port 8193 default) or HSSB (legacy serial bus)
-- Main implementation: `Cnc/Fanuc/FanucMachine.cs`
-- Dialect abstraction: `Cnc/Fanuc/IFocasDialect.cs` → `LegacyFocasDialect.cs` / `ModernFocasDialect.cs`
-- Auto-detection: `Cnc/Fanuc/FanucDialectDetector.cs` (detects FOCAS version at connect time)
-- Config: `Cnc/Fanuc/FanucConnectionConfig.cs` (IP, port, HSSB node, transport type)
-- Platform: Windows only (DLL is 32-bit native)
-
-**Heidenhain LSV2 (proprietary TCP protocol):**
-- Used for: Program transfer to/from Heidenhain iTNC/TNC controllers
-- Client: Custom TCP implementation `Cnc/Heidenhain/Lsv2Client.cs`
-- Default port: 19000
-- Auth: Username + password required
-- Framing: STX, SIZE, CMD, data, CRC-16/CCITT
-- Commands implemented: T_LS_SELECT, T_LS_LOG_IN, T_LS_LOG_OUT, T_R_FL (read file), T_S_FL (send file), T_FD
-- Main implementation: `Cnc/Heidenhain/HeidenhainMachine.cs`
-- Config: `Cnc/Heidenhain/HeidenhainConnectionConfig.cs`
-- Note: ReadActiveProgramAsync / SelectMainProgram not implemented (LSV2 limitation)
-
-**Siemens Sinumerik FTP:**
-- Used for: Program transfer to/from Siemens Sinumerik controllers
-- Protocol: Standard FTP (RFC 959) via `System.Net.FtpWebRequest`
-- Default port: 21
-- Default program dir: `/_N_MPF_DIR/`
-- Auth: Username + password
-- Client: `Cnc/Siemens/SiemensFtpClient.cs`
-- Main implementation: `Cnc/Siemens/SiemensMachine.cs`
-- Config: `Cnc/Siemens/SiemensConnectionConfig.cs`
-- Requirement: Sinumerik FTP option must be enabled on machine
-
-**Mitsubishi M-Series FTP:**
-- Used for: Program transfer to/from Mitsubishi M-series controllers
-- Protocol: Standard FTP (RFC 959) via `System.Net.FtpWebRequest`
-- Default port: 21
-- Default program dir: `/PRG/`
-- Auth: Username + password
-- Client: `Cnc/Mitsubishi/MitsubishiFtpClient.cs`
-- Main implementation: `Cnc/Mitsubishi/MitsubishiMachine.cs`
-- Config: `Cnc/Mitsubishi/MitsubishiConnectionConfig.cs`
-
-## Licensing System
-
-**RSA Offline License Validation:**
-- Used for: Binding license to specific machine hardware
-- Mechanism: RSA-SHA256 signature verification
-- Public key: Embedded as const string in `Licensing/LicenseValidator.cs`
-- Private key: Vendor-only, stored at `~/Documents/mine/c#/LicenseGenerator/private.key.xml` (gitignored)
-- Machine fingerprint: WMI queries (CPU ID + motherboard serial) via `Licensing/MachineFingerprint.cs`
-- License file: `license.lic` (Base64-encoded RSA signature) next to EXE
-- Crypto: `RSACryptoServiceProvider` + `SHA256CryptoServiceProvider` (.NET 4.7.2 compatible)
-- Generator tool: Separate repo `ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git`
-
-## Hardware Access
-
-**WMI (Windows Management Instrumentation):**
-- Used for: Machine fingerprinting in licensing
-- Queries: `Win32_Processor` (processorID), `Win32_BaseBoard` (SerialNumber)
-- Package: `System.Management 7.0.1`
-- Files: `Licensing/MachineFingerprint.cs`
-- Platform: Windows only
-
-## Data Storage
-
-**File System (local):**
-- NC program files written/read from local path specified via `-pathprogramma=` CLI arg
-- License file read from `AppDomain.CurrentDomain.BaseDirectory`
-- No database, no cloud storage
-
-## Monitoring & Observability
-
-- No error tracking service (Sentry, etc.)
-- No analytics
-- Logging: `Console.WriteLine` only (no structured logging framework)
-
----
-
-*Integrations analysis: 2026-05-18*
-*Update when new protocols or services are added*

.paul/codebase/STACK.md

@@ -1,83 +0,0 @@
-# Technology Stack
-
-**Analysis Date:** 2026-05-18
-
-## Languages
-
-**Primary:**
-- C# (.NET Framework 4.7.2) - All application code
-
-**Secondary:**
-- XML - Project files, App.config, binding redirects
-
-## Runtime
-
-**Environment:**
-- .NET Framework 4.7.2 — Windows only (FOCAS1 DLL + WMI)
-- No cross-platform support; Windows desktop/server target
-
-**Package Manager:**
-- NuGet (packages.config format, not PackageReference)
-- Lockfile: `packages.config` present in root and test project
-
-## Frameworks
-
-**Core:**
-- None (vanilla .NET console application)
-
-**Testing:**
-- NUnit 3.13.3 — Unit and integration tests (`NcProgramManager.Tests/packages.config`)
-- NUnit3TestAdapter 4.2.1 — VS / dotnet test runner
-- Moq 4.18.4 — Interface mocking
-
-**Build/IL Weaving:**
-- Fody 6.6.4 — IL code weaver (`NcProgramManager.csproj`)
-- Costura.Fody 5.7.0 — Embeds NuGet assemblies + native DLLs into output EXE
-
-## Key Dependencies
-
-**Critical:**
-- `System.Management 7.0.1` — WMI queries for machine fingerprinting (`Licensing/MachineFingerprint.cs`)
-- `Microsoft.Bcl.AsyncInterfaces 7.0.0` — Async backport for .NET 4.7.2 (`packages.config`)
-- `System.Memory 4.5.5` — Span<T> and Memory<T> compatibility (`packages.config`)
-- `System.Runtime.CompilerServices.Unsafe 6.0.0` — Low-level ops (`packages.config`)
-- `System.Net.Sockets 4.3.0` — TCP networking for LSV2/FTP (`packages.config`)
-
-**Infrastructure:**
-- `NETStandard.Library 2.0.3` — .NET Standard facade (`packages.config`)
-- `System.Net.Http 4.3.4` — HTTP base infrastructure (`packages.config`)
-- `Castle.Core 5.1.1` — Moq dependency (`NcProgramManager.Tests/packages.config`)
-
-**Native (embedded via Costura.Fody):**
-- `Cnc/Fanuc/libs/Fwlib32.dll` — Fanuc FOCAS1 library (32-bit, ~629KB)
-- `Cnc/Fanuc/libs/fwlibe1.dll` — Extended FOCAS (~1MB)
-- `Cnc/Fanuc/libs/fwlibNCG.dll` — FOCAS NCG support (~2MB)
-
-## Configuration
-
-**Environment:**
-- No environment variables
-- All runtime config passed via CLI arguments (parsed by `ArgParser.cs`)
-- License file: `license.lic` next to EXE (no CLI override)
-
-**Build:**
-- `NcProgramManager.csproj` — MSBuild 15.0, OutputType=Exe
-- `App.config` — Runtime binding redirects only (no business settings)
-- `FodyWeavers.xml` — Costura assembly embedding config
-
-## Platform Requirements
-
-**Development:**
-- Windows (FOCAS1 DLL requires 32-bit Windows; WMI for licensing)
-- Visual Studio 2017+ or MSBuild 15+
-- Fanuc FOCAS DLL unavailable on Linux (test suite ignores FOCAS tests)
-
-**Production:**
-- Windows (desktop or server)
-- `license.lic` placed alongside EXE
-- 32-bit process or AnyCPU with 32-bit preferred (FOCAS1 DLL constraint)
-
----
-
-*Stack analysis: 2026-05-18*
-*Update after major dependency changes*

.paul/codebase/STRUCTURE.md

@@ -1,160 +0,0 @@
-# Codebase Structure
-
-**Analysis Date:** 2026-05-18
-
-## Directory Layout
-
-```
-nc_program_manager/
-├── NcProgramManager/               # Main application
-│   ├── Program.cs                  # CLI entry point, action dispatch
-│   ├── ArgParser.cs                # CLI argument parser
-│   ├── InputArgs.cs                # Parsed args config object
-│   ├── FanucProgram.cs             # Fanuc composite NC file parser
-│   ├── fwlib32.cs                  # Fanuc FOCAS1 P/Invoke wrapper (auto-gen, 11K lines)
-│   ├── NcProgramManager.csproj     # Project file (.NET 4.7.2, Console)
-│   ├── App.config                  # Runtime binding redirects
-│   ├── packages.config             # NuGet dependencies
-│   ├── Licensing/                  # License validation subsystem
-│   ├── Cnc/                        # CNC abstraction + implementations
-│   │   ├── ICncMachine.cs
-│   │   ├── IFanucMachine.cs
-│   │   ├── INcProgramValidator.cs
-│   │   ├── NcProgramValidator.cs
-│   │   ├── CncMachineFactory.cs
-│   │   ├── Models/                 # DTOs and value objects
-│   │   ├── Fanuc/                  # FOCAS protocol
-│   │   │   └── libs/              # Native DLLs (embedded)
-│   │   ├── Heidenhain/             # LSV2 protocol
-│   │   ├── Siemens/                # FTP protocol
-│   │   └── Mitsubishi/             # FTP protocol
-│   └── Properties/
-│       └── AssemblyInfo.cs
-├── NcProgramManager.Tests/         # Test suite
-│   ├── Unit/                       # Isolated unit tests
-│   ├── Integration/                # Protocol integration tests
-│   │   └── Stubs/                 # In-process server stubs
-│   ├── NcProgramManager.Tests.csproj
-│   ├── packages.config
-│   └── nunit.runsettings
-├── NcProgramManager.sln            # Solution file
-├── Dockerfile.test                 # Containerized test runner
-└── README.md                       # Italian operator docs
-```
-
-## Directory Purposes
-
-**`Licensing/`:**
-- Purpose: RSA-based offline license validation
-- Key files: `LicenseValidator.cs`, `MachineFingerprint.cs`, `LicenseFile.cs`, `ILicenseValidator.cs`, `IMachineFingerprint.cs`
-
-**`Cnc/Models/`:**
-- Purpose: Shared DTOs and value objects for CNC layer
-- Key files: `CncResult.cs`, `CncError.cs`, `CncManufacturer.cs`, `CncProgram.cs`, `ConnectionState.cs`, `ValidationError.cs`, `ValidationResult.cs`, `ValidationSeverity.cs`, `MachineSnapshot.cs`, `MachineMode.cs`, `MotionState.cs`, `RunState.cs`
-
-**`Cnc/Fanuc/`:**
-- Purpose: Fanuc FOCAS protocol implementation
-- Key files: `FanucMachine.cs` (main), `FanucConnectionConfig.cs`, `IFocasDialect.cs`, `LegacyFocasDialect.cs`, `ModernFocasDialect.cs`, `FocasDialectFactory.cs`, `FanucDialectDetector.cs`, `FanucErrorTranslator.cs`, `IsoProgramFormatter.cs`, `FanucCapabilities.cs`, `FanucTransport.cs`
-
-**`Cnc/Heidenhain/`:**
-- Purpose: Heidenhain LSV2 protocol implementation
-- Key files: `HeidenhainMachine.cs`, `Lsv2Client.cs`, `ILsv2Client.cs`, `HeidenhainConnectionConfig.cs`
-
-**`Cnc/Siemens/`:**
-- Purpose: Siemens FTP protocol implementation
-- Key files: `SiemensMachine.cs`, `SiemensFtpClient.cs`, `ISiemensFtpClient.cs`, `SiemensConnectionConfig.cs`
-
-**`Cnc/Mitsubishi/`:**
-- Purpose: Mitsubishi FTP protocol implementation
-- Key files: `MitsubishiMachine.cs`, `MitsubishiFtpClient.cs`, `IMitsubishiFtpClient.cs`, `MitsubishiConnectionConfig.cs`
-
-**`NcProgramManager.Tests/Unit/`:**
-- Purpose: Isolated unit tests with mocks
-- Key files: `NcProgramValidatorTests.cs`, `FanucMachineTests.cs`, `FanucProgramParsingTests.cs`, `IsoProgramFormatterTests.cs`, `CncMachineFactoryTests.cs`, `LicenseValidatorTests.cs`, `SiemensMachineTests.cs`, `MitsubishiMachineTests.cs`, `HeidenhainMachineTests.cs`
-
-**`NcProgramManager.Tests/Integration/`:**
-- Purpose: Protocol-level tests using in-process stubs
-- Key files: `HeidenhainMachineIntegrationTests.cs`, `SiemensMachineIntegrationTests.cs`, `MitsubishiMachineIntegrationTests.cs`
-
-**`NcProgramManager.Tests/Integration/Stubs/`:**
-- Purpose: In-process server stubs for protocol testing
-- Key files: `FtpServerStub.cs` (FTP server with in-memory file store), `Lsv2ServerStub.cs` (LSV2 TCP server)
-
-## Key File Locations
-
-**Entry Points:**
-- `Program.cs` — Main(), CLI orchestration, exit codes
-- `ArgParser.cs` — static `Parse(string[]) → InputArgs`
-
-**Configuration:**
-- `NcProgramManager.csproj` — Project metadata, NuGet refs, build config
-- `App.config` — Binding redirects only
-- `packages.config` — NuGet dependency list
-
-**Core Logic:**
-- `Cnc/ICncMachine.cs` — Primary abstraction interface
-- `Cnc/CncMachineFactory.cs` — Manufacturer dispatch
-- `Cnc/Models/CncResult.cs` — Result wrapper pattern
-- `Cnc/Fanuc/FanucMachine.cs` — Largest impl (~740 lines)
-- `Licensing/LicenseValidator.cs` — License check entry
-
-**Testing:**
-- `NcProgramManager.Tests/Unit/NcProgramValidatorTests.cs` — Most comprehensive unit tests
-- `NcProgramManager.Tests/Integration/Stubs/FtpServerStub.cs` — Reusable FTP stub
-
-**Documentation:**
-- `README.md` — Italian operator-facing docs (CLI args, license setup, error codes)
-
-## Naming Conventions
-
-**Files:**
-- PascalCase for all `.cs` files: `FanucMachine.cs`, `CncResult.cs`
-- Interfaces prefixed with I: `ICncMachine.cs`, `IFocasDialect.cs`
-- Config classes: `{Manufacturer}ConnectionConfig.cs`
-- Test files: `{Subject}Tests.cs` or `{Subject}IntegrationTests.cs`
-
-**Directories:**
-- PascalCase for manufacturer dirs: `Fanuc/`, `Heidenhain/`, `Siemens/`, `Mitsubishi/`
-- Lowercase for support: `libs/`
-
-## Where to Add New Code
-
-**New CNC manufacturer:**
-- Implementation: `Cnc/{Manufacturer}/{Manufacturer}Machine.cs` (implement `ICncMachine`)
-- Config: `Cnc/{Manufacturer}/{Manufacturer}ConnectionConfig.cs`
-- Client: `Cnc/{Manufacturer}/I{Manufacturer}FtpClient.cs` + `{Manufacturer}FtpClient.cs` (if FTP)
-- Wire: Add case to `Cnc/CncMachineFactory.cs`
-- Enum: Add value to `Cnc/Models/CncManufacturer.cs`
-- Args: Update `ArgParser.cs` if new transport args needed
-
-**New Fanuc FOCAS feature:**
-- Add to `Cnc/Fanuc/IFocasDialect.cs`, implement in `LegacyFocasDialect.cs` + `ModernFocasDialect.cs`
-- Surface in `Cnc/Fanuc/FanucMachine.cs`
-- If Fanuc-specific CLI exposure: update `IFanucMachine.cs`, `Program.cs`
-
-**New validation rule:**
-- Add to `Cnc/NcProgramValidator.cs`
-- Add test to `NcProgramManager.Tests/Unit/NcProgramValidatorTests.cs`
-
-**New CLI arg:**
-- Add to `ArgParser.cs` regex parsing
-- Add field to `InputArgs.cs`
-- Update `README.md` params table
-
-## Special Directories
-
-**`Cnc/Fanuc/libs/`:**
-- Purpose: Native Fanuc FOCAS DLLs
-- Source: Fanuc-provided proprietary binaries
-- Committed: Yes (required for build)
-- Embedded: Via Costura.Fody into output EXE
-
-**`.paul/`:**
-- Purpose: PAUL project planning state
-- Source: Generated/maintained by PAUL workflow
-- Committed: Yes
-
----
-
-*Structure analysis: 2026-05-18*
-*Update when directory structure changes*

.paul/codebase/TESTING.md

@@ -1,153 +0,0 @@
-# Testing Patterns
-
-**Analysis Date:** 2026-05-18
-
-## Test Framework
-
-**Runner:**
-- NUnit 3.13.3 — `NcProgramManager.Tests/packages.config`
-- NUnit3TestAdapter 4.2.1 — VS/dotnet test runner integration
-- Config: `NcProgramManager.Tests/nunit.runsettings`
-
-**Assertion Library:**
-- NUnit fluent API: `Assert.That(actual, Is.True)`, `Is.EqualTo()`, `Is.InstanceOf<T>()`
-
-**Mocking:**
-- Moq 4.18.4 for interface mocking
-- Castle.Core 5.1.1 (Moq dependency)
-- Custom delegates for `ref` parameter workaround (Moq limitation with P/Invoke refs)
-  - Example: `NcProgramManager.Tests/Unit/FanucMachineTests.cs`
-
-**Run Commands:**
-```bash
-# Standard NUnit runner or VS Test Explorer
-dotnet test NcProgramManager.Tests/NcProgramManager.Tests.csproj
-# Or via Dockerfile:
-docker build -f Dockerfile.test .
-```
-
-## Test File Organization
-
-**Location:**
-- All tests in `NcProgramManager.Tests/` (separate project)
-- Unit tests: `NcProgramManager.Tests/Unit/`
-- Integration tests: `NcProgramManager.Tests/Integration/`
-- Stubs: `NcProgramManager.Tests/Integration/Stubs/`
-
-**Naming:**
-- Unit: `{Subject}Tests.cs` — `NcProgramValidatorTests.cs`, `FanucMachineTests.cs`
-- Integration: `{Subject}IntegrationTests.cs` — `HeidenhainMachineIntegrationTests.cs`
-- Stubs: `{Protocol}ServerStub.cs` — `FtpServerStub.cs`, `Lsv2ServerStub.cs`
-
-## Test Structure
-
-**Fixture Pattern:**
-```csharp
-[TestFixture]
-public class NcProgramValidatorTests
-{
-    [SetUp]
-    public void SetUp() { ... }
-
-    [Test]
-    public void MethodName_Condition_ExpectedResult()
-    {
-        // arrange
-        // act
-        // assert (NUnit fluent)
-    }
-}
-```
-
-**Parameterized Tests:**
-```csharp
-[TestCase(CncManufacturer.Fanuc)]
-[TestCase(CncManufacturer.Siemens)]
-[TestCase(CncManufacturer.Heidenhain)]
-[TestCase(CncManufacturer.Mitsubishi)]
-public void Validate_TabCharacter_ReturnsWarning(CncManufacturer m) { ... }
-```
-Example: `NcProgramManager.Tests/Unit/NcProgramValidatorTests.cs`
-
-**Async Tests:**
-- No `async Task` test methods — use `.GetAwaiter().GetResult()` to block
-  - Example: `NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs`
-
-**Test Categories:**
-```csharp
-[Category("Integration")]  // marks integration tests
-```
-
-## Mocking
-
-**Interface mocking via Moq:**
-```csharp
-var mockDialect = new Mock<IFocasDialect>();
-mockDialect.Setup(d => d.Connect(...)).Returns(...);
-var machine = new FanucMachine(config, mockDialect.Object);
-```
-Example: `NcProgramManager.Tests/Unit/FanucMachineTests.cs`
-
-**Reflection-based state injection (for bypassing protected fields):**
-```csharp
-// Set internal connection state without real hardware
-typeof(FanucMachine)
-    .GetField("_state", BindingFlags.NonPublic | BindingFlags.Instance)
-    .SetValue(machine, ConnectionState.Connected);
-```
-Example: `NcProgramManager.Tests/Unit/FanucMachineTests.cs`
-
-**What to mock:**
-- Protocol interfaces: `IFocasDialect`, `ILsv2Client`, `ISiemensFtpClient`, `IMitsubishiFtpClient`
-- Licensing: `IMachineFingerprint`, `ILicenseValidator`
-
-## In-Process Protocol Stubs
-
-**FtpServerStub** (`NcProgramManager.Tests/Integration/Stubs/FtpServerStub.cs`):
-- Minimal FTP server for Siemens/Mitsubishi integration testing
-- In-memory file store: `Dictionary<string, string> Files`
-- Supported commands: USER, PASS, CWD, TYPE, PASV, LIST, NLST, RETR, STOR, DELE
-- Usage: Start before test, inject port into machine config
-
-**Lsv2ServerStub** (`NcProgramManager.Tests/Integration/Stubs/Lsv2ServerStub.cs`):
-- Minimal LSV2 TCP server for Heidenhain integration testing
-- Implements LSV2 framing (STX, SIZE, CMD, data, CRC)
-- Thread-per-client architecture
-
-## Ignored Tests
-
-**FOCAS DLL-dependent tests marked `[Ignore]`:**
-- All tests requiring actual `Fwlib32.dll` calls are ignored
-- Reason: Cannot mock static P/Invoke calls; DLL requires real Fanuc hardware on Windows
-- Example: `NcProgramManager.Tests/Unit/FanucMachineTests.cs`
-
-**Pattern for skipping:**
-```csharp
-[Test]
-[Ignore("Requires Fanuc FOCAS DLL and real hardware")]
-public void ConnectAsync_ValidConfig_Connects() { ... }
-```
-
-## Coverage Approach
-
-**Well-covered:**
-- `NcProgramValidator` — universal rules + all 4 manufacturers, 30+ test cases
-  - `NcProgramManager.Tests/Unit/NcProgramValidatorTests.cs`
-- `FanucProgram` parsing — `FanucProgramParsingTests.cs`
-- `IsoProgramFormatter` — `IsoProgramFormatterTests.cs`
-- `CncMachineFactory` dispatch — `CncMachineFactoryTests.cs`
-- `LicenseValidator` — 6 unit tests via internal ctor injection — `LicenseValidatorTests.cs`
-
-**Partially covered (blocked by hardware):**
-- `FanucMachine` connect/read/write — FOCAS tests `[Ignore]`d
-- Heidenhain/Siemens/Mitsubishi machines — integration tests use stubs
-
-**Not covered:**
-- `MachineFingerprint` (WMI, Windows-only, no mocked tests)
-- `LicenseFile` parsing edge cases
-- `Program.cs` CLI orchestration (no CLI-level tests)
-
----
-
-*Testing analysis: 2026-05-18*
-*Update when test framework or patterns change*

.paul/paul.json

@@ -1,19 +1,19 @@
 {
   "name": "NcProgramManager",
-  "version": "0.4.0",
+  "version": "0.3.0",
   "milestone": {
-    "name": "v0.4 Robustness",
-    "version": "0.4.0",
+    "name": "v0.3 Code Quality",
+    "version": "0.3.0",
     "status": "complete"
   },
   "phase": {
-    "number": 14,
-    "name": "test-hardening",
+    "number": 12,
+    "name": "docs-cli",
     "status": "complete"
   },
   "loop": {
-    "plan": null,
-    "position": "IDLE"
+    "plan": "12-01",
+    "position": "UNIFY_DONE"
   },
   "timestamps": {
     "created_at": "2026-05-13T00:00:00Z",

.paul/phases/13-robustness-fixes/13-01-PLAN.md

@@ -1,175 +0,0 @@
----
-phase: 13-robustness-fixes
-plan: 01
-type: execute
-wave: 1
-depends_on: []
-files_modified:
-  - Licensing/MachineFingerprint.cs
-  - Licensing/LicenseValidator.cs
-  - Cnc/Heidenhain/Lsv2Client.cs
-autonomous: true
----
-
-<objective>
-## Goal
-Fix three targeted robustness defects: null dereference in WMI fingerprinting (ISS-001), undisposed SHA256 crypto provider (ISS-005), and LSV2 connect timeout that leaves a hung socket task (ISS-006).
-
-## Purpose
-Shipping software with an unguarded null dereference in the license check means customers on unusual hardware get an unhandled exception with no diagnostic. The crypto leak is minor but correctness matters in security-sensitive code. The Lsv2Client timeout bug means a Heidenhain machine that is unreachable stalls the process indefinitely.
-
-## Output
-Three modified source files. No new files. No interface changes.
-</objective>
-
-<context>
-@.paul/PROJECT.md
-@.paul/ISSUES.md
-@Licensing/MachineFingerprint.cs
-@Licensing/LicenseValidator.cs
-@Cnc/Heidenhain/Lsv2Client.cs
-</context>
-
-<acceptance_criteria>
-
-## AC-1: MachineFingerprint null guard
-```gherkin
-Given a Windows machine where a WMI property (processorID or SerialNumber) returns null
-When GetFingerprint() is called
-Then it returns a non-null string (partial or "unknown") instead of throwing NullReferenceException
-```
-
-## AC-2: SHA256 provider disposed
-```gherkin
-Given LicenseValidator.Validate() is called with any input
-When the method completes (success or failure)
-Then the SHA256CryptoServiceProvider created during verification has been disposed
-```
-
-## AC-3: LSV2 connect timeout aborts socket
-```gherkin
-Given a Heidenhain machine IP that is unreachable (no TCP response)
-When Lsv2Client.Connect() is called and the ConnectTimeout elapses
-Then Connect() returns false AND the pending TcpClient socket is closed (no lingering thread-pool task)
-```
-
-</acceptance_criteria>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Null-guard WMI property reads in MachineFingerprint</name>
-  <files>Licensing/MachineFingerprint.cs</files>
-  <action>
-    In GetFingerprint(), replace both unguarded property accesses with null-safe equivalents:
-
-    Line 16 — replace:
-      pcInfo = mo.Properties["processorID"].Value.ToString();
-    with:
-      pcInfo = mo.Properties["processorID"]?.Value?.ToString() ?? string.Empty;
-
-    Line 26 — replace:
-      pcInfo += obj["SerialNumber"].ToString();
-    with:
-      pcInfo += obj["SerialNumber"]?.ToString() ?? string.Empty;
-
-    Do NOT change the method signature, interface, or logic flow. Only the two property reads.
-    Do NOT add logging or throw — empty string fallback is intentional (fingerprint may be partial but won't crash).
-  </action>
-  <verify>Read the modified file and confirm both lines use ?. and ?? string.Empty</verify>
-  <done>AC-1 satisfied: no unguarded .ToString() calls on WMI properties</done>
-</task>
-
-<task type="auto">
-  <name>Task 2: Wrap SHA256CryptoServiceProvider in using block</name>
-  <files>Licensing/LicenseValidator.cs</files>
-  <action>
-    In Validate(), the inner rsa using block currently does:
-      return rsa.VerifyData(data, new SHA256CryptoServiceProvider(), signature);
-
-    Replace with a nested using so SHA256 is disposed:
-      using (var sha256 = new SHA256CryptoServiceProvider())
-      {
-          return rsa.VerifyData(data, sha256, signature);
-      }
-
-    The outer `using (var rsa = new RSACryptoServiceProvider())` remains unchanged.
-    The enclosing try/catch remains unchanged.
-    Do NOT change the public key constant, constructor, or method signature.
-    Do NOT switch to HashAlgorithmName — that requires a different VerifyData overload not available on .NET 4.7.2 RSACryptoServiceProvider cleanly. Keep the existing overload.
-  </action>
-  <verify>Read the modified file and confirm SHA256CryptoServiceProvider is inside a using statement</verify>
-  <done>AC-2 satisfied: SHA256CryptoServiceProvider disposed after every Validate() call</done>
-</task>
-
-<task type="auto">
-  <name>Task 3: Close TcpClient on connect timeout in Lsv2Client</name>
-  <files>Cnc/Heidenhain/Lsv2Client.cs</files>
-  <action>
-    In Connect(), the current code:
-      if (!_tcp.ConnectAsync(_config.IpAddress, _config.Port).Wait(_config.ConnectTimeout))
-          return false;
-
-    The bug: .Wait(timeout) returns false but leaves the pending ConnectAsync task running,
-    holding a thread-pool slot. Fix by closing _tcp on timeout to abort the socket:
-
-    Replace those two lines with:
-      var connectTask = _tcp.ConnectAsync(_config.IpAddress, _config.Port);
-      if (!connectTask.Wait((int)_config.ConnectTimeout.TotalMilliseconds))
-      {
-          try { _tcp.Close(); } catch { }
-          return false;
-      }
-
-    The `_tcp.Close()` call disposes the underlying socket, causing the pending Task to
-    complete with a SocketException/ObjectDisposedException rather than hanging forever.
-
-    Do NOT change anything else in Connect() or any other method.
-    Do NOT add async/await — Connect() is synchronous by design (.NET 4.7.2, called via GetAwaiter().GetResult() in HeidenhainMachine).
-    Do NOT touch Disconnect(), Login(), SendCommand(), ReadFrame(), or Crc16().
-  </action>
-  <verify>Read the modified Connect() method and confirm: (a) connectTask is assigned, (b) _tcp.Close() is called inside the timeout branch</verify>
-  <done>AC-3 satisfied: timeout branch closes the socket before returning false</done>
-</task>
-
-</tasks>
-
-<boundaries>
-
-## DO NOT CHANGE
-- `Licensing/LicenseValidator.cs` public key constant (line 10) — vendor key, must not be modified
-- `Licensing/IMachineFingerprint.cs` — interface unchanged
-- `Licensing/ILicenseValidator.cs` — interface unchanged
-- `Cnc/Heidenhain/HeidenhainMachine.cs` — not in scope
-- `Cnc/Heidenhain/ILsv2Client.cs` — interface unchanged
-- Any test files — Phase 14 handles test changes
-
-## SCOPE LIMITS
-- No new dependencies or NuGet packages
-- No async/await refactor (ISS-002 is deferred to a future phase)
-- No logging framework (ISS-003/ISS-004 deferred)
-- No changes to any other machine implementations (Fanuc, Siemens, Mitsubishi)
-- No changes to RSA key, licensing logic, or fingerprint algorithm — only defensive null guards
-
-</boundaries>
-
-<verification>
-Before declaring plan complete:
-- [ ] `Licensing/MachineFingerprint.cs` — both WMI reads use `?.` and `?? string.Empty`
-- [ ] `Licensing/LicenseValidator.cs` — SHA256CryptoServiceProvider in using statement
-- [ ] `Cnc/Heidenhain/Lsv2Client.cs` — Connect() calls `_tcp.Close()` in the timeout branch
-- [ ] No other files modified
-- [ ] No interface signatures changed
-- [ ] Build not broken (no new compile errors introduced)
-</verification>
-
-<success_criteria>
-- All 3 tasks completed
-- All 3 verification checks pass
-- ISS-001, ISS-005, ISS-006 addressed
-- No regressions in existing code paths
-</success_criteria>
-
-<output>
-After completion, create `.paul/phases/13-robustness-fixes/13-01-SUMMARY.md`
-</output>

.paul/phases/13-robustness-fixes/13-01-SUMMARY.md

@@ -1,70 +0,0 @@
----
-phase: 13-robustness-fixes
-plan: 01
-type: summary
-status: complete
-completed: 2026-05-18
-commit: 4cd7715
----
-
-# Summary: Plan 13-01 — Robustness Fixes
-
-## What Was Built
-
-Three targeted defensive fixes. No new files. No interface changes.
-
-### Task 1 — MachineFingerprint null guard (ISS-001)
-
-**File:** `Licensing/MachineFingerprint.cs`
-
-Both WMI property reads now use null-safe operators:
-- `mo.Properties["processorID"]?.Value?.ToString() ?? string.Empty`
-- `obj["SerialNumber"]?.ToString() ?? string.Empty`
-
-Customers on hardware where WMI returns null for processorID or SerialNumber no longer get an unhandled NullReferenceException at license check startup.
-
-### Task 2 — SHA256 provider disposed (ISS-005)
-
-**File:** `Licensing/LicenseValidator.cs`
-
-`SHA256CryptoServiceProvider` wrapped in `using` block inside `Validate()`. Disposed on every call — success or failure. RSACryptoServiceProvider pattern unchanged. Public key constant untouched.
-
-### Task 3 — LSV2 connect timeout aborts socket (ISS-006)
-
-**File:** `Cnc/Heidenhain/Lsv2Client.cs`
-
-`Connect()` now calls `_tcp.Close()` when `ConnectAsync().Wait(timeout)` returns false. Closes the underlying socket, causing the pending task to complete with SocketException rather than holding a thread-pool slot indefinitely. No async/await introduced (Connect() stays synchronous by design).
-
-## Acceptance Criteria Results
-
-| AC | Description | Result |
-|----|-------------|--------|
-| AC-1 | WMI null returns non-null string, no throw | PASS |
-| AC-2 | SHA256 provider disposed after every Validate() | PASS |
-| AC-3 | Timeout branch closes socket before returning false | PASS |
-
-## Decisions Made
-
-- `?? string.Empty` used (not `?? "unknown"`) — fingerprint string concatenated; empty is correct fallback
-- `_tcp.Close()` in bare `try { } catch { }` — same pattern as existing Disconnect() in same file
-- No CancellationTokenSource pattern (ISS-006 fix note suggested it) — simpler Close() approach sufficient for .NET 4.7.2 synchronous design
-
-## Deferred
-
-None — all three tasks completed as planned.
-
-## Files Modified
-
-- `Licensing/MachineFingerprint.cs` — null guards on WMI reads
-- `Licensing/LicenseValidator.cs` — SHA256 using block
-- `Cnc/Heidenhain/Lsv2Client.cs` — socket close on timeout
-
-## Issues Closed
-
-- ISS-001 — MachineFingerprint null dereference on unusual hardware ✓
-- ISS-005 — SHA256 crypto provider not disposed ✓
-- ISS-006 — LSV2 connect timeout doesn't abort hung task ✓
-
-## Commit
-
-`4cd7715` — fix(robustness): null guard WMI reads, dispose SHA256, abort LSV2 timeout (ISS-001, ISS-005, ISS-006)

.paul/phases/14-test-hardening/14-01-PLAN.md

@@ -1,344 +0,0 @@
----
-phase: 14-test-hardening
-plan: 01
-type: tdd
-wave: 1
-depends_on: []
-files_modified:
-  - NcProgramManager.Tests/Integration/HardwareTestHelper.cs
-  - NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs
-  - NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs
-  - NcProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs
-  - NcProgramManager.Tests/Unit/LicenseFileTests.cs
-  - NcProgramManager.Tests/Unit/LicenseValidatorTests.cs
-autonomous: true
----
-
-<objective>
-## Goal
-Fix ISS-007 and ISS-008: add opt-in hardware test scaffolding via env vars, and cover LicenseFile edge cases plus IMachineFingerprint mock integration in unit tests.
-
-## Purpose
-Stub-based integration tests already run; without an env-var pattern there is no supported path to run against real hardware in CI or manually. LicenseFile has only one test (non-existent path) — empty-file and whitespace-only branches are untested. The IMachineFingerprint mock pattern ensures the license flow is documented as testable without WMI.
-
-## Output
-Two new test files (`HardwareTestHelper.cs`, `LicenseFileTests.cs`) and additions to three existing test files. No production code changes.
-</objective>
-
-<context>
-@.paul/PROJECT.md
-@.paul/ISSUES.md
-@NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs
-@NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs
-@NcProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs
-@NcProgramManager.Tests/Unit/LicenseValidatorTests.cs
-@Licensing/LicenseFile.cs
-</context>
-
-<acceptance_criteria>
-
-## AC-1: Hardware tests skip when env var not set
-```gherkin
-Given no HEIDENHAIN_IP / SIEMENS_IP / MITSUBISHI_IP environment variable is set
-When the [Category("Hardware")] test runs in standard CI
-Then NUnit reports it as Ignored (not Failed), with message "Hardware test skipped: <VAR> not set."
-```
-
-## AC-2: Hardware tests run when env var is set
-```gherkin
-Given HEIDENHAIN_IP (or SIEMENS_IP / MITSUBISHI_IP) is set to a valid IP string
-When the [Category("Hardware")] test runs
-Then it attempts ConnectAsync against that IP with the default protocol port (no stub)
-```
-
-## AC-3: LicenseFile empty/whitespace files return false
-```gherkin
-Given a real temp file that exists but contains empty bytes or only whitespace/newlines
-When LicenseFile.TryRead() is called with that path
-Then it returns false and the out parameter is null
-```
-
-## AC-4: LicenseFile valid content returns true with trimmed base64
-```gherkin
-Given a real temp file containing a valid base64 string followed by a newline
-When LicenseFile.TryRead() is called with that path
-Then it returns true and the out parameter equals the trimmed base64 string
-```
-
-## AC-5: IMachineFingerprint mock — empty fingerprint does not crash validator
-```gherkin
-Given a Moq Mock<IMachineFingerprint> that returns empty string from GetFingerprint()
-When LicenseValidator.Validate(mockFingerprint.GetFingerprint(), anyLicense) is called
-Then it returns false without throwing
-```
-
-</acceptance_criteria>
-
-<tasks>
-
-<task type="auto">
-  <name>Task 1: Create HardwareTestHelper and add hardware test variants to 3 integration test files</name>
-  <files>
-    NcProgramManager.Tests/Integration/HardwareTestHelper.cs,
-    NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs,
-    NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs,
-    NcProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs
-  </files>
-  <action>
-    1. Create `NcProgramManager.Tests/Integration/HardwareTestHelper.cs`:
-
-       ```csharp
-       using System;
-       using NUnit.Framework;
-
-       namespace NcProgramManager.Tests.Integration
-       {
-           internal static class HardwareTestHelper
-           {
-               internal static string GetIpOrSkip(string envVarName)
-               {
-                   string ip = Environment.GetEnvironmentVariable(envVarName);
-                   if (string.IsNullOrEmpty(ip))
-                       Assert.Ignore("Hardware test skipped: " + envVarName + " not set.");
-                   return ip;
-               }
-           }
-       }
-       ```
-
-    2. In `HeidenhainMachineIntegrationTests.cs`, add this method inside the class (after existing tests):
-
-       ```csharp
-       [Test]
-       [Category("Hardware")]
-       public void Hardware_ConnectAsync_RealMachine()
-       {
-           string ip = HardwareTestHelper.GetIpOrSkip("HEIDENHAIN_IP");
-           var config = new HeidenhainConnectionConfig
-           {
-               Name     = "HeidenhainHardware",
-               IpAddress     = ip,
-               Port          = 19000,
-               Username      = Environment.GetEnvironmentVariable("HEIDENHAIN_USER") ?? "user",
-               Password      = Environment.GetEnvironmentVariable("HEIDENHAIN_PASS") ?? "pass",
-               ConnectTimeout = TimeSpan.FromSeconds(10)
-           };
-           using (var machine = new HeidenhainMachine(config))
-           {
-               var result = machine.ConnectAsync().GetAwaiter().GetResult();
-               Assert.That(result.Success, Is.True, "ConnectAsync failed: " + result.Error);
-           }
-       }
-       ```
-
-       Do NOT modify the existing stub-based tests — only add the new hardware method.
-
-    3. In `SiemensMachineIntegrationTests.cs`, add inside the class:
-
-       ```csharp
-       [Test]
-       [Category("Hardware")]
-       public void Hardware_ConnectAsync_RealMachine()
-       {
-           string ip = HardwareTestHelper.GetIpOrSkip("SIEMENS_IP");
-           var config = new SiemensConnectionConfig
-           {
-               Name             = "SiemensHardware",
-               IpAddress        = ip,
-               Port             = 21,
-               Username         = Environment.GetEnvironmentVariable("SIEMENS_USER") ?? "user",
-               Password         = Environment.GetEnvironmentVariable("SIEMENS_PASS") ?? "pass",
-               ProgramDirectory = "/_N_MPF_DIR/",
-               RequestTimeout   = TimeSpan.FromSeconds(10)
-           };
-           using (var machine = new SiemensMachine(config))
-           {
-               var result = machine.ConnectAsync().GetAwaiter().GetResult();
-               Assert.That(result.Success, Is.True, "ConnectAsync failed: " + result.Error);
-           }
-       }
-       ```
-
-    4. In `MitsubishiMachineIntegrationTests.cs`, add inside the class:
-
-       ```csharp
-       [Test]
-       [Category("Hardware")]
-       public void Hardware_ConnectAsync_RealMachine()
-       {
-           string ip = HardwareTestHelper.GetIpOrSkip("MITSUBISHI_IP");
-           var config = new MitsubishiConnectionConfig
-           {
-               Name             = "MitsubishiHardware",
-               IpAddress        = ip,
-               Port             = 21,
-               Username         = Environment.GetEnvironmentVariable("MITSUBISHI_USER") ?? "user",
-               Password         = Environment.GetEnvironmentVariable("MITSUBISHI_PASS") ?? "pass",
-               ProgramDirectory = "/PRG/",
-               RequestTimeout   = TimeSpan.FromSeconds(10)
-           };
-           using (var machine = new MitsubishiMachine(config))
-           {
-               var result = machine.ConnectAsync().GetAwaiter().GetResult();
-               Assert.That(result.Success, Is.True, "ConnectAsync failed: " + result.Error);
-           }
-       }
-       ```
-
-    Constraints:
-    - Use `System.Environment.GetEnvironmentVariable` (available .NET 4.7.2)
-    - Use `Assert.Ignore()` (NUnit 3) — NOT `[Ignore]` attribute (static) — so it skips at runtime when var missing
-    - Do NOT use `CancellationToken` or async/await — machine classes are sync-by-design
-    - The hardware test disposes the machine itself (using block) — does not use class-level `_machine` or `_stub` fields
-  </action>
-  <verify>
-    Read all 4 files:
-    - HardwareTestHelper.cs exists with `GetIpOrSkip` calling `Assert.Ignore`
-    - Each integration test file has `Hardware_ConnectAsync_RealMachine` with `[Category("Hardware")]`
-    - No existing stub tests modified
-  </verify>
-  <done>AC-1 and AC-2 satisfied: hardware tests skip if env var absent, connect if present</done>
-</task>
-
-<task type="auto">
-  <name>Task 2: Create LicenseFileTests and add IMachineFingerprint mock test to LicenseValidatorTests</name>
-  <files>
-    NcProgramManager.Tests/Unit/LicenseFileTests.cs,
-    NcProgramManager.Tests/Unit/LicenseValidatorTests.cs
-  </files>
-  <action>
-    1. Create `NcProgramManager.Tests/Unit/LicenseFileTests.cs`:
-
-       ```csharp
-       using System.IO;
-       using NUnit.Framework;
-       using NcProgramManager.Licensing;
-
-       namespace NcProgramManager.Tests.Unit
-       {
-           [TestFixture]
-           internal class LicenseFileTests
-           {
-               private string _tempPath;
-
-               [SetUp]
-               public void SetUp()
-               {
-                   _tempPath = Path.GetTempFileName();
-               }
-
-               [TearDown]
-               public void TearDown()
-               {
-                   if (File.Exists(_tempPath))
-                       File.Delete(_tempPath);
-               }
-
-               [Test]
-               public void TryRead_EmptyFile_ReturnsFalse()
-               {
-                   File.WriteAllText(_tempPath, string.Empty);
-                   bool result = LicenseFile.TryRead(_tempPath, out string base64);
-                   Assert.IsFalse(result);
-                   Assert.IsNull(base64);
-               }
-
-               [Test]
-               public void TryRead_WhitespaceOnly_ReturnsFalse()
-               {
-                   File.WriteAllText(_tempPath, "   \n\r\n  ");
-                   bool result = LicenseFile.TryRead(_tempPath, out string base64);
-                   Assert.IsFalse(result);
-                   Assert.IsNull(base64);
-               }
-
-               [Test]
-               public void TryRead_ValidBase64Content_ReturnsTrueWithTrimmedValue()
-               {
-                   string expected = "SGVsbG8gV29ybGQ=";
-                   File.WriteAllText(_tempPath, expected + "\n");
-                   bool result = LicenseFile.TryRead(_tempPath, out string base64);
-                   Assert.IsTrue(result);
-                   Assert.AreEqual(expected, base64);
-               }
-
-               [Test]
-               public void TryRead_NonExistentPath_ReturnsFalse()
-               {
-                   bool result = LicenseFile.TryRead(_tempPath + ".notexist", out string base64);
-                   Assert.IsFalse(result);
-                   Assert.IsNull(base64);
-               }
-           }
-       }
-       ```
-
-    2. In `LicenseValidatorTests.cs`, add one test method at the bottom of the class (before closing brace):
-
-       ```csharp
-       [Test]
-       public void Validate_EmptyFingerprint_ReturnsFalse()
-       {
-           // Empty fingerprint — matches no valid license; must not throw
-           Assert.IsFalse(_validator.Validate(string.Empty, Sign("CPU123")));
-       }
-       ```
-
-       This uses `_validator` already set up in `[SetUp]` (test-keyed validator), so no new fields needed.
-
-    Constraints:
-    - `Path.GetTempFileName()` creates a 0-byte file, so `TearDown` must delete it
-    - `LicenseFile.TryRead` is internal + static — accessible from test project because NcProgramManager uses `[assembly: InternalsVisibleTo("NcProgramManager.Tests")]` (verify this exists; if not, note it as a blocker)
-    - Do NOT test `LicenseFile.TryRead` with a directory path — edge case not worth the OS-specific behavior
-    - Do NOT add Moq for `IMachineFingerprint` — existing `LicenseValidator(string publicKeyXml)` ctor makes the empty-fingerprint test straightforward without mock overhead
-  </action>
-  <verify>
-    - Read `LicenseFileTests.cs` — 4 test methods present, all use temp file, TearDown deletes
-    - Read `LicenseValidatorTests.cs` — `Validate_EmptyFingerprint_ReturnsFalse` present at end of class
-    - Check `Properties/AssemblyInfo.cs` or project-level for `InternalsVisibleTo` declaration — if missing, flag it
-  </verify>
-  <done>AC-3, AC-4, AC-5 satisfied: LicenseFile edge cases covered; empty fingerprint handled gracefully</done>
-</task>
-
-</tasks>
-
-<boundaries>
-
-## DO NOT CHANGE
-- `Licensing/LicenseFile.cs` — production code; no changes in this phase
-- `Licensing/LicenseValidator.cs` — public key constant must not be modified
-- `Licensing/MachineFingerprint.cs` — fixed in Phase 13; not in scope
-- All existing test methods — no modifications; only additions
-- `Cnc/**/*.cs` — no production machine code
-
-## SCOPE LIMITS
-- No Moq mocking of `IMachineFingerprint` in tests — the `LicenseValidator(string)` ctor injection already enables unit testing without mocks; Moq mock would add complexity for no test coverage gain
-- Hardware tests only add `ConnectAsync` verification — no write/read against real hardware (unsafe without known machine state)
-- No new NuGet packages — Moq 4.18.4 already present; NUnit 3.13.3 already present
-- No async/await in test methods — stay consistent with existing test style (`.GetAwaiter().GetResult()`)
-
-</boundaries>
-
-<verification>
-Before declaring plan complete:
-- [ ] `HardwareTestHelper.cs` exists with `GetIpOrSkip(string) → string` calling `Assert.Ignore` if env var empty
-- [ ] `HeidenhainMachineIntegrationTests.cs` — `Hardware_ConnectAsync_RealMachine` test added, `[Category("Hardware")]` present
-- [ ] `SiemensMachineIntegrationTests.cs` — `Hardware_ConnectAsync_RealMachine` test added
-- [ ] `MitsubishiMachineIntegrationTests.cs` — `Hardware_ConnectAsync_RealMachine` test added
-- [ ] `LicenseFileTests.cs` exists with 4 test methods
-- [ ] `LicenseValidatorTests.cs` — `Validate_EmptyFingerprint_ReturnsFalse` added
-- [ ] `InternalsVisibleTo` for `LicenseFile` accessible from test project (check or flag if missing)
-- [ ] No production files modified
-</verification>
-
-<success_criteria>
-- All 2 tasks completed
-- All 5 ACs covered
-- ISS-007 and ISS-008 addressed
-- No existing tests broken
-- No production code modified
-</success_criteria>
-
-<output>
-After completion, create `.paul/phases/14-test-hardening/14-01-SUMMARY.md`
-</output>

.paul/phases/14-test-hardening/14-01-SUMMARY.md

@@ -1,140 +0,0 @@
----
-phase: 14-test-hardening
-plan: 01
-subsystem: testing
-tags: [nunit, hardware-testing, license, env-var, integration-tests]
-
-requires:
-  - phase: 13-robustness-fixes
-    provides: ISS-001/005/006 fixes; stable production code baseline
-
-provides:
-  - HardwareTestHelper with env-var skip pattern for all 3 machine types
-  - LicenseFile edge-case unit tests (empty, whitespace, valid, nonexistent)
-  - Empty-fingerprint guard test for LicenseValidator
-
-affects: future hardware CI configuration, ISS-007, ISS-008
-
-tech-stack:
-  added: []
-  patterns: [env-var-gated hardware tests via Assert.Ignore, temp-file teardown pattern]
-
-key-files:
-  created:
-    - NcProgramManager.Tests/Integration/HardwareTestHelper.cs
-    - NcProgramManager.Tests/Unit/LicenseFileTests.cs
-  modified:
-    - NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs
-    - NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs
-    - NcProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs
-    - NcProgramManager.Tests/Unit/LicenseValidatorTests.cs
-    - NcProgramManager.Tests/NcProgramManager.Tests.csproj
-
-key-decisions:
-  - "Assert.Ignore() at runtime (not [Ignore] attribute) — enables dynamic skip based on env var"
-  - "No Moq for IMachineFingerprint — LicenseValidator(string) ctor injection sufficient"
-
-patterns-established:
-  - "Hardware test pattern: HardwareTestHelper.GetIpOrSkip(VAR_NAME) at test start"
-  - "Temp file tests: Path.GetTempFileName() in SetUp, File.Delete in TearDown"
-
-duration: ~20min
-started: 2026-05-18T00:00:00Z
-completed: 2026-05-18T00:00:00Z
----
-
-# Phase 14 Plan 01: Test Hardening Summary
-
-**Env-var-gated hardware test scaffolding added for all 3 machine types; LicenseFile edge cases and empty-fingerprint guard covered in unit tests.**
-
-## Performance
-
-| Metric | Value |
-|--------|-------|
-| Duration | ~20min |
-| Started | 2026-05-18 |
-| Completed | 2026-05-18 |
-| Tasks | 2 completed |
-| Files modified | 7 |
-
-## Acceptance Criteria Results
-
-| Criterion | Status | Notes |
-|-----------|--------|-------|
-| AC-1: Hardware tests skip when env var not set | Pass | `Assert.Ignore` fires at runtime; NUnit reports Ignored |
-| AC-2: Hardware tests run when env var set | Pass | `ConnectAsync` called against env-var IP |
-| AC-3: LicenseFile empty/whitespace → false | Pass | `TryRead_EmptyFile` + `TryRead_WhitespaceOnly` |
-| AC-4: LicenseFile valid base64 → true trimmed | Pass | `TryRead_ValidBase64Content_ReturnsTrueWithTrimmedValue` |
-| AC-5: Empty fingerprint → false, no throw | Pass | `Validate_EmptyFingerprint_ReturnsFalse` |
-
-## Accomplishments
-
-- `HardwareTestHelper.GetIpOrSkip` — single call gates any hardware test; works for all 3 machine types
-- 4 new `LicenseFileTests` covering all `TryRead` branches (empty, whitespace, valid, nonexistent)
-- `Validate_EmptyFingerprint_ReturnsFalse` documents that validator is safe against empty input
-- `.csproj` wired — old-style explicit `<Compile>` entries added for both new files
-
-## Files Created/Modified
-
-| File | Change | Purpose |
-|------|--------|---------|
-| `NcProgramManager.Tests/Integration/HardwareTestHelper.cs` | Created | Env-var skip helper |
-| `NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs` | Modified | Added `Hardware_ConnectAsync_RealMachine` |
-| `NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs` | Modified | Added `Hardware_ConnectAsync_RealMachine` |
-| `NcProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs` | Modified | Added `Hardware_ConnectAsync_RealMachine` |
-| `NcProgramManager.Tests/Unit/LicenseFileTests.cs` | Created | LicenseFile edge-case tests |
-| `NcProgramManager.Tests/Unit/LicenseValidatorTests.cs` | Modified | Added `Validate_EmptyFingerprint_ReturnsFalse` |
-| `NcProgramManager.Tests/NcProgramManager.Tests.csproj` | Modified | `<Compile>` entries for 2 new files |
-
-## Decisions Made
-
-| Decision | Rationale | Impact |
-|----------|-----------|--------|
-| `Assert.Ignore()` not `[Ignore]` attribute | Static attribute can't read env var at test-start; runtime call can | Hardware skip works correctly with env vars |
-| No Moq for `IMachineFingerprint` | `LicenseValidator(string)` ctor injection already enables unit testing; mock adds no coverage | Simpler test, no extra dependency wiring |
-
-## Deviations from Plan
-
-### Summary
-
-| Type | Count | Impact |
-|------|-------|--------|
-| Auto-fixed | 1 | Essential — without fix, new files excluded from build |
-| Scope additions | 0 | — |
-| Deferred | 0 | — |
-
-**Total impact:** One essential fix, no scope creep.
-
-### Auto-fixed Issues
-
-**1. Missing `<Compile>` entries in old-style `.csproj`**
-- **Found during:** Task 2 qualify
-- **Issue:** `NcProgramManager.Tests.csproj` uses explicit `<Compile>` includes; new files not auto-discovered
-- **Fix:** Added `<Compile Include="Integration\HardwareTestHelper.cs" />` and `<Compile Include="Unit\LicenseFileTests.cs" />`
-- **Files:** `NcProgramManager.Tests/NcProgramManager.Tests.csproj`
-- **Verification:** Grep confirmed both entries present
-
-## Issues Addressed
-
-| Issue | Resolution |
-|-------|------------|
-| ISS-007: Integration test IPs hardcoded | Closed — env-var pattern replaces hardcoded IPs for hardware paths |
-| ISS-008: MachineFingerprint untested on real Windows hardware | Partially addressed — hardware test scaffold in place; full closure requires real Windows hardware run |
-
-## Next Phase Readiness
-
-**Ready:**
-- All v0.4 planned work complete (Phase 13 + Phase 14)
-- ISS-007 closed; ISS-008 scaffold in place
-- Test suite has clean skip pattern for hardware-only tests
-
-**Concerns:**
-- Build not verified on Windows (no toolchain on dev Linux machine) — first Windows build will confirm compile
-- ISS-008 full closure needs manual run on real Windows hardware with `HEIDENHAIN_IP` etc. set
-
-**Blockers:**
-- None for milestone closure
-
----
-*Phase: 14-test-hardening, Plan: 01*
-*Completed: 2026-05-18*

Cnc/Heidenhain/Lsv2Client.cs

@@ -30,12 +30,8 @@ namespace NcProgramManager.Cnc.Heidenhain
             _tcp = new TcpClient();
             _tcp.SendTimeout    = (int)_config.ConnectTimeout.TotalMilliseconds;
             _tcp.ReceiveTimeout = (int)_config.ConnectTimeout.TotalMilliseconds;
-            var connectTask = _tcp.ConnectAsync(_config.IpAddress, _config.Port);
-            if (!connectTask.Wait((int)_config.ConnectTimeout.TotalMilliseconds))
-            {
-                try { _tcp.Close(); } catch { }
+            if (!_tcp.ConnectAsync(_config.IpAddress, _config.Port).Wait(_config.ConnectTimeout))
                 return false;
-            }
             _stream = _tcp.GetStream();
             return Login();
         }

Licensing/LicenseValidator.cs

@@ -29,10 +29,7 @@ namespace NcProgramManager.Licensing
                 using (var rsa = new RSACryptoServiceProvider())
                 {
                     rsa.FromXmlString(_publicKeyXml);
-                    using (var sha256 = new SHA256CryptoServiceProvider())
-                    {
-                        return rsa.VerifyData(data, sha256, signature);
-                    }
+                    return rsa.VerifyData(data, new SHA256CryptoServiceProvider(), signature);
                 }
             }
             catch

Licensing/MachineFingerprint.cs

@@ -13,7 +13,7 @@ namespace NcProgramManager.Licensing
             {
                 foreach (ManagementObject mo in moc)
                 {
-                    pcInfo = mo.Properties["processorID"]?.Value?.ToString() ?? string.Empty;
+                    pcInfo = mo.Properties["processorID"].Value.ToString();
                     break;
                 }
             }
@@ -23,7 +23,7 @@ namespace NcProgramManager.Licensing
             {
                 foreach (ManagementObject obj in searcher.Get())
                 {
-                    pcInfo += obj["SerialNumber"]?.ToString() ?? string.Empty;
+                    pcInfo += obj["SerialNumber"].ToString();
                     break;
                 }
             }

NcProgramManager.Tests/Integration/HardwareTestHelper.cs

@@ -1,16 +0,0 @@
-using System;
-using NUnit.Framework;
-
-namespace NcProgramManager.Tests.Integration
-{
-    internal static class HardwareTestHelper
-    {
-        internal static string GetIpOrSkip(string envVarName)
-        {
-            string ip = Environment.GetEnvironmentVariable(envVarName);
-            if (string.IsNullOrEmpty(ip))
-                Assert.Ignore("Hardware test skipped: " + envVarName + " not set.");
-            return ip;
-        }
-    }
-}

NcProgramManager.Tests/Integration/HeidenhainMachineIntegrationTests.cs

@@ -76,26 +76,5 @@ namespace NcProgramManager.Tests.Integration
 
             Assert.That(result.Success, Is.False);
         }
-
-        [Test]
-        [Category("Hardware")]
-        public void Hardware_ConnectAsync_RealMachine()
-        {
-            string ip = HardwareTestHelper.GetIpOrSkip("HEIDENHAIN_IP");
-            var config = new HeidenhainConnectionConfig
-            {
-                Name          = "HeidenhainHardware",
-                IpAddress     = ip,
-                Port          = 19000,
-                Username      = Environment.GetEnvironmentVariable("HEIDENHAIN_USER") ?? "user",
-                Password      = Environment.GetEnvironmentVariable("HEIDENHAIN_PASS") ?? "pass",
-                ConnectTimeout = TimeSpan.FromSeconds(10)
-            };
-            using (var machine = new HeidenhainMachine(config))
-            {
-                var result = machine.ConnectAsync().GetAwaiter().GetResult();
-                Assert.That(result.Success, Is.True, "ConnectAsync failed: " + result.Error);
-            }
-        }
     }
 }

NcProgramManager.Tests/Integration/MitsubishiMachineIntegrationTests.cs

@@ -92,27 +92,5 @@ namespace NcProgramManager.Tests.Integration
 
             Assert.That(result.Success, Is.False);
         }
-
-        [Test]
-        [Category("Hardware")]
-        public void Hardware_ConnectAsync_RealMachine()
-        {
-            string ip = HardwareTestHelper.GetIpOrSkip("MITSUBISHI_IP");
-            var config = new MitsubishiConnectionConfig
-            {
-                Name             = "MitsubishiHardware",
-                IpAddress        = ip,
-                Port             = 21,
-                Username         = Environment.GetEnvironmentVariable("MITSUBISHI_USER") ?? "user",
-                Password         = Environment.GetEnvironmentVariable("MITSUBISHI_PASS") ?? "pass",
-                ProgramDirectory = "/PRG/",
-                RequestTimeout   = TimeSpan.FromSeconds(10)
-            };
-            using (var machine = new MitsubishiMachine(config))
-            {
-                var result = machine.ConnectAsync().GetAwaiter().GetResult();
-                Assert.That(result.Success, Is.True, "ConnectAsync failed: " + result.Error);
-            }
-        }
     }
 }

NcProgramManager.Tests/Integration/SiemensMachineIntegrationTests.cs

@@ -100,27 +100,5 @@ namespace NcProgramManager.Tests.Integration
 
             Assert.That(result.Success, Is.False);
         }
-
-        [Test]
-        [Category("Hardware")]
-        public void Hardware_ConnectAsync_RealMachine()
-        {
-            string ip = HardwareTestHelper.GetIpOrSkip("SIEMENS_IP");
-            var config = new SiemensConnectionConfig
-            {
-                Name             = "SiemensHardware",
-                IpAddress        = ip,
-                Port             = 21,
-                Username         = Environment.GetEnvironmentVariable("SIEMENS_USER") ?? "user",
-                Password         = Environment.GetEnvironmentVariable("SIEMENS_PASS") ?? "pass",
-                ProgramDirectory = "/_N_MPF_DIR/",
-                RequestTimeout   = TimeSpan.FromSeconds(10)
-            };
-            using (var machine = new SiemensMachine(config))
-            {
-                var result = machine.ConnectAsync().GetAwaiter().GetResult();
-                Assert.That(result.Success, Is.True, "ConnectAsync failed: " + result.Error);
-            }
-        }
     }
 }

NcProgramManager.Tests/NcProgramManager.Tests.csproj

@@ -63,11 +63,9 @@
     <Compile Include="Unit\HeidenhainMachineTests.cs" />
     <Compile Include="Integration\Stubs\FtpServerStub.cs" />
     <Compile Include="Integration\Stubs\Lsv2ServerStub.cs" />
-    <Compile Include="Integration\HardwareTestHelper.cs" />
     <Compile Include="Integration\SiemensMachineIntegrationTests.cs" />
     <Compile Include="Integration\MitsubishiMachineIntegrationTests.cs" />
     <Compile Include="Integration\HeidenhainMachineIntegrationTests.cs" />
-    <Compile Include="Unit\LicenseFileTests.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

NcProgramManager.Tests/Unit/LicenseFileTests.cs

@@ -1,61 +0,0 @@
-using System.IO;
-using NUnit.Framework;
-using NcProgramManager.Licensing;
-
-namespace NcProgramManager.Tests.Unit
-{
-    [TestFixture]
-    internal class LicenseFileTests
-    {
-        private string _tempPath;
-
-        [SetUp]
-        public void SetUp()
-        {
-            _tempPath = Path.GetTempFileName();
-        }
-
-        [TearDown]
-        public void TearDown()
-        {
-            if (File.Exists(_tempPath))
-                File.Delete(_tempPath);
-        }
-
-        [Test]
-        public void TryRead_EmptyFile_ReturnsFalse()
-        {
-            File.WriteAllText(_tempPath, string.Empty);
-            bool result = LicenseFile.TryRead(_tempPath, out string base64);
-            Assert.IsFalse(result);
-            Assert.IsNull(base64);
-        }
-
-        [Test]
-        public void TryRead_WhitespaceOnly_ReturnsFalse()
-        {
-            File.WriteAllText(_tempPath, "   \n\r\n  ");
-            bool result = LicenseFile.TryRead(_tempPath, out string base64);
-            Assert.IsFalse(result);
-            Assert.IsNull(base64);
-        }
-
-        [Test]
-        public void TryRead_ValidBase64Content_ReturnsTrueWithTrimmedValue()
-        {
-            string expected = "SGVsbG8gV29ybGQ=";
-            File.WriteAllText(_tempPath, expected + "\n");
-            bool result = LicenseFile.TryRead(_tempPath, out string base64);
-            Assert.IsTrue(result);
-            Assert.AreEqual(expected, base64);
-        }
-
-        [Test]
-        public void TryRead_NonExistentPath_ReturnsFalse()
-        {
-            bool result = LicenseFile.TryRead(_tempPath + ".notexist", out string base64);
-            Assert.IsFalse(result);
-            Assert.IsNull(base64);
-        }
-    }
-}

NcProgramManager.Tests/Unit/LicenseValidatorTests.cs

@@ -76,12 +76,5 @@ namespace NcProgramManager.Tests.Unit
             Assert.IsFalse(result);
             Assert.IsNull(base64);
         }
-
-        [Test]
-        public void Validate_EmptyFingerprint_ReturnsFalse()
-        {
-            // Empty fingerprint — matches no valid license; must not throw
-            Assert.IsFalse(_validator.Validate(string.Empty, Sign("CPU123")));
-        }
     }
 }