feat(11-refactor): extract ArgParser, fix error handling, remove dead code

Phase 11 complete:
- ArgParser.cs: CLI parsing extracted from Program.cs (pure static method)
- Program.cs: no static state; Scarica/Invia take explicit InputArgs param
- Program.cs: try/finally with connected flag — fixes connection leak on exception
- Program.cs: PrintErrors helper surfaces CncResult.Errors on every failure
- AesCrypt.cs: deleted (dead code, zero references)
- NcProgramManager.csproj: AesCrypt.cs → ArgParser.cs

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.paul/PROJECT.md

@@ -13,8 +13,8 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 | Attribute | Value |
 |-----------|-------|
 | Type | Application |
-| Version | 0.2.0-dev |
+| Version | 0.2.0 |
-| Status | v0.2 in progress — Phase 07 complete |
+| Status | v0.2 complete |
 | Last Updated | 2026-05-17 |
 
 ## Requirements
@@ -38,11 +38,13 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 
 ### Validated (Shipped) — continued
 - [x] RSA offline license core: IMachineFingerprint, ILicenseValidator, LicenseValidator, LicenseFile — Phase 7
+- [x] License wired into Program.cs — RSA check at startup, license.lic next to EXE, -chiave= removed — Phase 8
+- [x] LicenseGenerator standalone tool (keygen, fingerprint, sign) — Phase 9
+- [x] Real RSA 2048-bit key pair generated; PublicKeyXml embedded in LicenseValidator.cs — Phase 9
+- [x] ArgParser extracted — CLI parsing isolated from Program.cs; AesCrypt.cs dead code removed — Phase 11
+- [x] Connection leak fixed — try/finally in Scarica/Invia; CncResult.Errors surfaced on failure — Phase 11
 
 ### Planned (Next)
-- [ ] Wire license into Program.cs — replace checkLicense, replace -chiave= with -licfile= (Phase 08)
-- [ ] License generator tool — sign fingerprint with RSA private key, write .lic file (Phase 09)
-- [ ] Replace PublicKeyXml PLACEHOLDER with real vendor key pair (Phase 09 output)
 - [ ] ReadActiveProgramAsync / SelectMainProgram for Heidenhain and Siemens
 - [ ] Integration test against real hardware (Heidenhain, Siemens, Mitsubishi)
 
@@ -61,8 +63,8 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 
 ### Business Constraints
 - Software must be license-protected (offline, machine-bound)
-- Current approach: hardcoded machine check — needs improvement
+- License approach: RSA-SHA256 asymmetric, machine fingerprint (WMI CPU+board), .lic file next to EXE
-- Target: hardware fingerprint + encrypted license file
+- Vendor issues licenses with LicenseGenerator.exe; private key never distributed
 
 ## Key Decisions
 
@@ -74,7 +76,7 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 | `#` = Warning in Fanuc/Mitsubishi | Macro variable indicator — valid in context | 2026-05-13 | Active |
 | Constructor injection for validator | Internal ctor accepts mock — enables unit testing without Windows DLL | 2026-05-13 | Active |
 | RSA asymmetric licensing | Private key vendor-only; public key embedded in binary — decompiler can't forge licenses | 2026-05-17 | Active |
-| PublicKeyXml PLACEHOLDER until Phase 09 | Real key pair not yet generated; prevents blocking Phase 07 on Phase 09 | 2026-05-17 | Active |
+| LicenseGenerator as standalone separate repo | Vendor tool, never shipped to customers; separate lifecycle from NcProgramManager | 2026-05-17 | Active |
 | Heidenhain LSV2 port 19000 | Standard LSV2 port; needs real hardware verification | 2026-05-13 | Active |
 | Siemens FTP dir `/_N_MPF_DIR/` | Sinumerik standard MPF directory; FTP option must be enabled | 2026-05-13 | Active |
 
@@ -83,7 +85,7 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 | Metric | Target | Current | Status |
 |--------|--------|---------|--------|
 | Program transfer correctness | 100% (byte-verified) | Unknown | Pending hardware test |
-| License validation (offline) | Works without network | RSA core built, wiring Phase 08 | In progress |
+| License validation (offline) | Works without network | RSA + LicenseGenerator complete; needs Windows hardware test | Done (pending HW test) |
 | Multi-CN support | ≥2 manufacturers | 4 (Fanuc/Heidenhain/Siemens/Mitsubishi) | Done |
 | NC validation coverage | All manufacturers | 4 manufacturers, 30+ tests | Done |
 
@@ -98,10 +100,10 @@ Machinists and operators transfer CNC programs to/from any controller without ma
 | CN Protocol (Siemens) | FTP (FtpWebRequest) | ASCII mode, passive, `/_N_MPF_DIR/` |
 | CN Protocol (Mitsubishi) | FTP (FtpWebRequest) | Port 21, `/PRG/`, no extensions |
 | Validation | NcProgramValidator | Universal + per-manufacturer rules |
-| Encryption | AES (AesCrypt.cs) | Program file protection |
+| Encryption | AES | AesCrypt.cs removed (dead code) — encryption not active |
-| Licensing | RSA-SHA256 asymmetric | IMachineFingerprint + ILicenseValidator; wiring in Phase 08 |
+| Licensing | RSA-SHA256 asymmetric | IMachineFingerprint + ILicenseValidator + LicenseGenerator; real key pair embedded |
 | Testing | NUnit 3.13.3 + Moq 4.18.4 | .NET 4.7.2 test project |
 
 ---
 *PROJECT.md — Updated when requirements or context change*
-*Last updated: 2026-05-17 after Phase 7 (License Core)*
+*Last updated: 2026-05-18 after Phase 11 (refactor) — v0.3 in progress*

.paul/ROADMAP.md

@@ -84,16 +84,17 @@ Completed: 2026-05-13
 
 ## Next Milestone
 
-**v0.2 NcProgramManager** (in progress)
+**v0.2 NcProgramManager** ✅ Complete
-Status: In Progress
+Status: Complete
-Phases: 3 of 4 complete
+Phases: 4 of 4 complete
+Completed: 2026-05-17
 
-| Phase | Name | Plans | Status |
+| Phase | Name | Plans | Status | Completed |
-|-------|------|-------|--------|
+|-------|------|-------|--------|-----------|
-| 06 | rename-cleanup | 1 | ✅ Complete |
+| 06 | rename-cleanup | 1 | ✅ Complete | 2026-05-17 |
-| 07 | license-core | 1 | ✅ Complete |
+| 07 | license-core | 1 | ✅ Complete | 2026-05-17 |
 | 08 | license-integration | 1 | ✅ Complete | 2026-05-17 |
-| 09 | license-generator | 1 | Not started |
+| 09 | license-generator | 1 | ✅ Complete | 2026-05-17 |
 
 ### Phase 06: rename-cleanup ✅
 **Goal:** Rename FanucProgramManager → NcProgramManager (namespace, project files, test folder). Delete dead FANUCMachine.cs.
@@ -110,9 +111,47 @@ Phases: 3 of 4 complete
 **Completed:** 2026-05-17
 **Plans:** [x] 08-01: Program.cs wiring
 
-### Phase 09: license-generator (proposed)
+### Phase 09: license-generator ✅
 **Goal:** Separate generator console app — reads machine fingerprint, signs, writes `.lic` file
-**Depends on:** Phase 07
+**Completed:** 2026-05-17
+**Plans:** [x] 09-01: LicenseGenerator standalone tool + real public key embedded
 
 ---
-*Roadmap updated: 2026-05-17 — Phase 08 license-integration complete*
+
+## Standalone Phases (post-v0.2)
+
+| Phase | Name | Plans | Status |
+|-------|------|-------|--------|
+| 10 | readme-docs | 1 | ✅ Complete | 2026-05-17 |
+
+### Phase 10: readme-docs ✅
+**Goal:** Write Italian README for NcProgramManager and LicenseGenerator repos — describe what each does, prerequisites, setup, CLI usage, license workflow.
+**Depends on:** Phase 09 (license workflow complete)
+**Plans:** [x] 10-01: Italian READMEs for both repos
+
+---
+
+## Milestone v0.3 — Code Quality
+
+Status: In progress
+Phases: 2 of 2 planned
+
+| Phase | Name | Plans | Status | Completed |
+|-------|------|-------|--------|-----------|
+| 11 | refactor | 2 | ✅ Complete | 2026-05-18 |
+| 12 | docs-cli | 1 | Not started | — |
+
+### Phase 11: refactor ✅
+**Goal:** Clean Architecture refactor of Program.cs — extract ArgParser, fix error handling in Scarica/Invia (try/finally, surface CncResult.Errors), remove AesCrypt dead code.
+**Completed:** 2026-05-18
+**Plans:**
+- [x] 11-01: Extract ArgParser + clean Program.cs structure
+- [x] 11-02: Fix Scarica/Invia error handling
+
+### Phase 12: docs-cli
+**Goal:** Complete README parameter table — all 15 CLI args with descriptions.
+**Plans:**
+- [ ] 12-01: README complete CLI reference
+
+---
+*Roadmap updated: 2026-05-17 — v0.3 milestone added.*

.paul/STATE.md

@@ -5,27 +5,39 @@
 See: .paul/PROJECT.md (updated 2026-05-17)
 
 **Core value:** Machinists transfer CNC programs to/from any controller without manual steps or internet
-**Current focus:** v0.2 — Phase 08 complete, Phase 09 (license-generator) next
+**Current focus:** All phases complete — project fully documented
 
 ## Current Position
 
-Milestone: v0.2 NcProgramManager
+Milestone: v0.3 Code Quality
-Phase: 4 of 4 (09-license-generator) — Not started
+Phase: 12 of 2 (docs-cli) — Not started
-Status: Phase 08 complete, ready to plan Phase 09
+Plan: Not started
-Last activity: 2026-05-17 — Phase 08 license-integration complete (UNIFY done)
+Status: Ready to plan Phase 12
+Last activity: 2026-05-18 — Phase 11 (refactor) complete, transitioned to Phase 12
 
 Progress:
 - Milestone v0.1: [██████████] 100% (complete)
-- Milestone v0.2: [███████░░░] 75%
+- Milestone v0.2: [██████████] 100% (complete)
-- Phase 09: [░░░░░░░░░░] 0%
+- Milestone v0.3: [█████░░░░░] 50%
+- Phase 11 (refactor): [██████████] 100% (complete)
+- Phase 12 (docs-cli): [░░░░░░░░░░] 0%
 
 ## Loop Position
 
 ```
 PLAN ──▶ APPLY ──▶ UNIFY
-  ✓        ✓        ✓     [Phase 08 closed]
+  ✓        ✓        ✓     [Phase 11 complete — ready to plan Phase 12]
 ```
 
+## What Was Built (v0.3 Code Quality — in progress)
+
+### Phase 11 — Refactor
+- `ArgParser.cs` — static class, `Parse(string[]) → InputArgs`; all CLI regex parsing extracted from Program.cs
+- `Program.cs` — no static state; `Scarica`/`Invia` take explicit `InputArgs`; `VediErrore` takes `bool debugMode`
+- `Program.cs` — try/finally with `connected` flag in `Scarica` and `Invia`; connection leak fixed
+- `Program.cs` — `PrintErrors(IReadOnlyList<CncError>)` helper; `CncResult.Errors` printed on every failure
+- `AesCrypt.cs` — deleted (dead code, no references)
+
 ## What Was Built (v0.1 Multi-CN Release)
 
 ### Phase 1 — CNC Abstraction
@@ -60,7 +72,7 @@ PLAN ──▶ APPLY ──▶ UNIFY
 - `FtpServerStub` + `Lsv2ServerStub` — in-process TCP stubs
 - Unit + integration tests; Fanuc FOCAS tests `[Ignore]`d (Windows-only DLL)
 
-## What Was Built (v0.2 NcProgramManager — in progress)
+## What Was Built (v0.2 NcProgramManager — complete)
 
 ### Phase 06 — Rename Cleanup
 - Namespace: `FanucProgramManager.*` → `NcProgramManager.*` (all files)
@@ -68,21 +80,24 @@ PLAN ──▶ APPLY ──▶ UNIFY
 
 ### Phase 07 — License Core
 - `IMachineFingerprint` / `ILicenseValidator` interfaces
-- `MachineFingerprint` — WMI CPU/BIOS fingerprint, SHA256 hash
+- `MachineFingerprint` — WMI CPU/BIOS fingerprint
 - `LicenseFile.TryRead` — reads `.lic` file, returns base64 signature
-- `LicenseValidator.Validate` — RSA-SHA256 verify; PLACEHOLDER public key until Phase 09
+- `LicenseValidator.Validate` — RSA-SHA256 verify
 - `LicenseValidatorTests` — 6 unit tests (testable via internal ctor injection)
 
 ### Phase 08 — License Integration
-- `Program.cs` — `checkLicense` deleted; RSA check wired at startup:
+- `Program.cs` — RSA check wired at startup; `checkLicense` deleted; `license.lic` next to EXE
-  ```csharp
+- `InputArgs.cs` — `-chiave=` field removed
-  string _licPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "license.lic");
+
-  if (!LicenseFile.TryRead(_licPath, out _licBase64)
+### Phase 09 — License Generator
-      || !new LicenseValidator().Validate(_licFingerprint, _licBase64)) { ... }
+- `LicenseGenerator` standalone console tool (separate repo: `ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git`)
-  ```
+- Commands: `keygen` (RSA 2048-bit pair), `fingerprint` (WMI, Windows), `sign` (RSA-SHA256 → .lic)
-- `InputArgs.cs` — `chiave` field removed
+- Real public key embedded in `Licensing/LicenseValidator.cs` (PLACEHOLDER removed)
-- `-chiave=` CLI arg removed; license file hardcoded next to EXE as `license.lic`
+- `private.key.xml` at `~/Documents/mine/c#/LicenseGenerator/` (gitignored — keep secure)
-- `MostraAiuto` updated: instructs user to place `license.lic` next to executable
+
+### Phase 10 — README Docs
+- `README.md` in NcProgramManager root — Italian, operator-facing: CLI args, license setup, examples, controllers table
+- `README.md` in LicenseGenerator repo — Italian, vendor-facing: keygen first-run, 4-step license issuance workflow, commands table, security
 
 ## CLI Args (current)
 - `-manufacturer=fanuc|heidenhain|siemens|mitsubishi` (default: fanuc)
@@ -101,27 +116,31 @@ PLAN ──▶ APPLY ──▶ UNIFY
 - `license.lic` always at `AppDomain.CurrentDomain.BaseDirectory` — no CLI override
 - `RSACryptoServiceProvider` + `SHA256CryptoServiceProvider` (not HashAlgorithmName) — .NET 4.7.2 compat
 - Constructor injection pattern: internal ctor accepts key XML — testable without Windows WMI
-- PublicKeyXml = PLACEHOLDER until Phase 09 generates real key pair
+- LicenseGenerator: standalone separate repo — vendor tool, never shipped to customers
 - Heidenhain: LSV2 port 19000, needs real hardware testing
 - Siemens: FTP `/_N_MPF_DIR/`, needs Sinumerik FTP option enabled on machine
 - `#` = Warning in Fanuc/Mitsubishi — macro variable indicator
 
 ### Deferred Issues
-- Real RSA key pair — Phase 09 output; copy PublicKeyXml into LicenseValidator.cs
-- `AesCrypt.cs` dead code — remove in future cleanup phase
 - Heidenhain: `ReadActiveProgramAsync` / `SelectMainProgram` not implemented
 - Siemens: same as Heidenhain
 - Build + integration not verifiable on Linux (fwlib32 Windows-only)
-- MachineFingerprint WMI — code-review verified, needs real Windows hardware test
+- 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 — Phase 09 can start.
+None — project complete.
+
+### Git State
+Last commit (NcProgramManager): see `git log --oneline`
+LicenseGenerator repo: commit `2ef68dd` — feat: initial LicenseGenerator
+Branch: main
 
 ## Session Continuity
 
 Last session: 2026-05-17
-Stopped at: Phase 08 UNIFY complete
+Stopped at: Phase 11 complete, phase 12 ready
-Next action: /paul:plan phase 09 license-generator
+Next action: /paul:plan for Phase 12 (docs-cli — README complete CLI reference)
 Resume file: .paul/ROADMAP.md
 
 ---

.paul/paul.json

@@ -1,15 +1,15 @@
 {
   "name": "NcProgramManager",
-  "version": "0.2.0-dev",
+  "version": "0.3.0",
   "milestone": {
-    "name": "v0.2 NcProgramManager",
+    "name": "v0.3 Code Quality",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "status": "in_progress"
   },
   "phase": {
-    "number": 8,
+    "number": 12,
-    "name": "license-integration",
+    "name": "docs-cli",
-    "status": "complete"
+    "status": "not_started"
   },
   "loop": {
     "plan": null,
@@ -17,7 +17,7 @@
   },
   "timestamps": {
     "created_at": "2026-05-13T00:00:00Z",
-    "updated_at": "2026-05-17T22:00:00Z"
+    "updated_at": "2026-05-18T00:00:00Z"
   },
   "satellite": {
     "groom": true

.paul/phases/09-license-generator/09-01-PLAN.md

@@ -0,0 +1,357 @@
+---
+phase: 09-license-generator
+plan: 01
+type: execute
+wave: 1
+depends_on: ["07-01"]
+files_modified:
+  - ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.csproj
+  - ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.sln
+  - ~/Documents/mine/c#/LicenseGenerator/Program.cs
+  - ~/Documents/mine/c#/LicenseGenerator/InputArgs.cs
+  - ~/Documents/mine/c#/LicenseGenerator/Commands/KeygenCommand.cs
+  - ~/Documents/mine/c#/LicenseGenerator/Commands/FingerprintCommand.cs
+  - ~/Documents/mine/c#/LicenseGenerator/Commands/SignCommand.cs
+  - ~/Documents/mine/c#/LicenseGenerator/Properties/AssemblyInfo.cs
+  - Licensing/LicenseValidator.cs
+autonomous: false
+---
+
+<objective>
+## Goal
+Build a standalone vendor console tool (`LicenseGenerator.exe`) in a separate repository at `~/Documents/mine/c#/LicenseGenerator`. Three commands: `keygen` (RSA pair), `fingerprint` (WMI), `sign` (produce `.lic`). After running keygen, replace the PLACEHOLDER in `LicenseValidator.cs` with the real public key.
+
+## Purpose
+Completes the offline license system. Without a real key pair, all production licenses are rejected. This tool gives the vendor the ability to issue machine-bound licenses and embeds the matching public key into the product binary.
+
+## Output
+- `~/Documents/mine/c#/LicenseGenerator/` — new standalone .NET 4.7.2 console project and solution
+- Git repo initialized, remote: `ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git`
+- `Licensing/LicenseValidator.cs` (in NcProgramManager) — PLACEHOLDER replaced with real RSA 2048-bit public key XML
+</objective>
+
+<context>
+## Project Context
+@.paul/PROJECT.md
+@.paul/STATE.md
+
+## Prior Work
+@.paul/phases/07-license-core/07-01-SUMMARY.md
+
+## Source Files
+@Licensing/LicenseValidator.cs
+@Licensing/MachineFingerprint.cs
+@Licensing/LicenseFile.cs
+</context>
+
+<acceptance_criteria>
+
+## AC-1: keygen produces RSA 2048-bit key pair
+```gherkin
+Given LicenseGenerator.exe is present
+When vendor runs `LicenseGenerator.exe keygen`
+Then private.key.xml written to current dir, public key XML printed to stdout
+And stdout message instructs vendor to paste public key into LicenseValidator.cs
+```
+
+## AC-2: fingerprint command prints machine fingerprint
+```gherkin
+Given LicenseGenerator.exe running on Windows with WMI access
+When vendor runs `LicenseGenerator.exe fingerprint`
+Then machine fingerprint string printed to stdout (CPU ProcessorID + BaseBoard SerialNumber, same logic as MachineFingerprint.GetFingerprint())
+```
+
+## AC-3: sign command produces valid .lic file
+```gherkin
+Given private.key.xml exists and fingerprint string is known
+When vendor runs `LicenseGenerator.exe sign -key=private.key.xml -fingerprint=<fp> -out=license.lic`
+Then license.lic written containing base64 RSA-SHA256 signature
+And LicenseValidator(publicKeyXml).Validate(fp, File.ReadAllText("license.lic").Trim()) returns true
+```
+
+## AC-4: LicenseValidator.cs uses real public key
+```gherkin
+Given keygen was run and public key XML captured
+When PublicKeyXml constant in LicenseValidator.cs is updated from PLACEHOLDER to real XML
+Then a license signed by the matching private key passes Validate()
+And a license signed by any other key fails Validate()
+```
+
+</acceptance_criteria>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Create LicenseGenerator project and git repo</name>
+  <files>
+    ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.sln,
+    ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.csproj,
+    ~/Documents/mine/c#/LicenseGenerator/Program.cs,
+    ~/Documents/mine/c#/LicenseGenerator/InputArgs.cs,
+    ~/Documents/mine/c#/LicenseGenerator/Properties/AssemblyInfo.cs,
+    ~/Documents/mine/c#/LicenseGenerator/.gitignore
+  </files>
+  <action>
+    Create `~/Documents/mine/c#/LicenseGenerator/` as a fully standalone project (NOT inside NcProgramManager).
+
+    **Directory layout:**
+    ```
+    LicenseGenerator/
+      LicenseGenerator.sln
+      LicenseGenerator.csproj
+      Program.cs
+      InputArgs.cs
+      Commands/          (empty dir, populated in Task 2+3)
+      Properties/
+        AssemblyInfo.cs
+      .gitignore
+    ```
+
+    **LicenseGenerator.csproj:**
+    - OutputType: Exe, TargetFrameworkVersion: v4.7.2, Platform: AnyCPU
+    - References: System, System.Core, System.Management
+    - Compile includes: Program.cs, InputArgs.cs, Properties/AssemblyInfo.cs, Commands\KeygenCommand.cs, Commands\FingerprintCommand.cs, Commands\SignCommand.cs
+
+    **LicenseGenerator.sln:** minimal VS2019-compatible solution referencing LicenseGenerator.csproj
+
+    **InputArgs.cs** (namespace LicenseGenerator):
+    - Field: `string Command` — args[0] if present, else ""
+    - Field: `string KeyPath` — value of `-key=`
+    - Field: `string Fingerprint` — value of `-fingerprint=`
+    - Field: `string OutPath` — value of `-out=`, default "license.lic"
+    - Static factory: `InputArgs Parse(string[] args)` — split each arg on first '='
+
+    **Program.cs** (namespace LicenseGenerator):
+    - Call `InputArgs.Parse(args)`
+    - Switch Command: "keygen" → KeygenCommand.Execute(), "fingerprint" → FingerprintCommand.Execute(), "sign" → SignCommand.Execute(args), default → print usage + Environment.Exit(1)
+    - Usage text lists all three commands
+
+    **AssemblyInfo.cs:** standard .NET 4.7.2 template, AssemblyVersion "1.0.0.0", product "LicenseGenerator"
+
+    **.gitignore:** standard C# gitignore (bin/, obj/, *.user, .vs/, packages/)
+
+    **Git setup (run after creating files):**
+    ```bash
+    cd ~/Documents/mine/c#/LicenseGenerator
+    git init
+    git remote add origin ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git
+    ```
+
+    Avoid: any reference to NcProgramManager.csproj or NcProgramManager.sln
+  </action>
+  <verify>
+    `ls ~/Documents/mine/c#/LicenseGenerator/` shows .sln, .csproj, Program.cs, InputArgs.cs, Properties/, Commands/, .gitignore
+    `git -C ~/Documents/mine/c#/LicenseGenerator remote -v` shows origin pointing to ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git
+  </verify>
+  <done>Project structure created; git repo initialized with correct remote.</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Implement keygen and fingerprint commands</name>
+  <files>
+    ~/Documents/mine/c#/LicenseGenerator/Commands/KeygenCommand.cs,
+    ~/Documents/mine/c#/LicenseGenerator/Commands/FingerprintCommand.cs
+  </files>
+  <action>
+    **KeygenCommand.cs** (namespace LicenseGenerator.Commands):
+    ```csharp
+    internal static class KeygenCommand
+    {
+        internal static void Execute()
+        {
+            using (var rsa = new RSACryptoServiceProvider(2048))
+            {
+                string privateXml = rsa.ToXmlString(true);
+                string publicXml  = rsa.ToXmlString(false);
+                File.WriteAllText("private.key.xml", privateXml);
+                Console.WriteLine("=== PUBLIC KEY XML — paste into LicenseValidator.cs ===");
+                Console.WriteLine(publicXml);
+                Console.WriteLine("========================================================");
+                Console.WriteLine("Private key saved: private.key.xml");
+                Console.WriteLine("KEEP private.key.xml SECRET — never distribute it.");
+            }
+        }
+    }
+    ```
+    Usings: System, System.IO, System.Security.Cryptography
+
+    **FingerprintCommand.cs** (namespace LicenseGenerator.Commands):
+    - Duplicate WMI logic from MachineFingerprint.GetFingerprint():
+      1. ManagementClass("win32_processor") → processorID property
+      2. ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_BaseBoard") → SerialNumber
+      3. Concatenate → print to Console.WriteLine
+    - Wrap in try/catch: on exception print "Error reading fingerprint (Windows + WMI required): " + ex.Message, Environment.Exit(1)
+    - Usings: System, System.Management
+
+    Avoid: referencing MachineFingerprint class from NcProgramManager — keep standalone
+  </action>
+  <verify>
+    On Linux/Mono: `LicenseGenerator.exe keygen` writes private.key.xml and prints RSAKeyValue XML to stdout.
+    On Windows: `LicenseGenerator.exe fingerprint` prints non-empty CPU+board string.
+  </verify>
+  <done>AC-1 satisfied: keygen generates 2048-bit RSA pair. AC-2 satisfied: fingerprint reads WMI.</done>
+</task>
+
+<task type="auto">
+  <name>Task 3: Implement sign command</name>
+  <files>
+    ~/Documents/mine/c#/LicenseGenerator/Commands/SignCommand.cs
+  </files>
+  <action>
+    **SignCommand.cs** (namespace LicenseGenerator.Commands):
+    ```csharp
+    internal static class SignCommand
+    {
+        internal static void Execute(InputArgs args)
+        {
+            if (string.IsNullOrEmpty(args.KeyPath))
+            {
+                Console.Error.WriteLine("Missing: -key=<path-to-private.key.xml>");
+                Environment.Exit(1);
+            }
+            if (string.IsNullOrEmpty(args.Fingerprint))
+            {
+                Console.Error.WriteLine("Missing: -fingerprint=<machine-fingerprint>");
+                Environment.Exit(1);
+            }
+
+            string privateXml = File.ReadAllText(args.KeyPath);
+            byte[] data = Encoding.UTF8.GetBytes(args.Fingerprint);
+
+            using (var rsa = new RSACryptoServiceProvider())
+            {
+                rsa.FromXmlString(privateXml);
+                byte[] signature = rsa.SignData(data, new SHA256CryptoServiceProvider());
+                string base64 = Convert.ToBase64String(signature);
+                File.WriteAllText(args.OutPath, base64);
+                Console.WriteLine("License written: " + args.OutPath);
+            }
+        }
+    }
+    ```
+    Usings: System, System.IO, System.Security.Cryptography, System.Text
+
+    SHA256CryptoServiceProvider (not HashAlgorithmName) — .NET 4.7.2 RSACryptoServiceProvider constraint.
+    SignData here MUST pair with VerifyData in LicenseValidator — same provider type on both sides.
+
+    Avoid: HashAlgorithmName overloads — not available in .NET 4.7.2 RSACryptoServiceProvider
+  </action>
+  <verify>
+    `LicenseGenerator.exe sign -key=private.key.xml -fingerprint=TEST_FP -out=test.lic` → test.lic contains non-empty base64.
+    Cross-check: `new LicenseValidator(publicKeyXml).Validate("TEST_FP", File.ReadAllText("test.lic").Trim())` returns true.
+  </verify>
+  <done>AC-3 satisfied: sign command produces .lic file verifiable by LicenseValidator.</done>
+</task>
+
+<task type="checkpoint:human-action" gate="blocking">
+  <what-built>LicenseGenerator project complete — keygen, fingerprint, sign commands implemented.</what-built>
+  <how-to-verify>
+    1. Build: `msbuild ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.sln /p:Configuration=Release`
+       (or on Windows: build via VS or msbuild)
+    2. Navigate to output: `LicenseGenerator/bin/Release/`
+    3. Run: `LicenseGenerator.exe keygen`
+    4. Capture the PUBLIC KEY XML printed between the `===` banners
+    5. Paste the captured XML in the resume signal below
+
+    Note: keygen works on Linux (Mono) and Windows — no WMI needed for key generation.
+  </how-to-verify>
+  <resume-signal>Paste captured public key XML (the full RSAKeyValue string) to continue</resume-signal>
+</task>
+
+<task type="auto">
+  <name>Task 4: Replace PublicKeyXml PLACEHOLDER in LicenseValidator.cs</name>
+  <files>
+    Licensing/LicenseValidator.cs
+  </files>
+  <action>
+    In NcProgramManager project, replace the PLACEHOLDER in `Licensing/LicenseValidator.cs`.
+
+    Current (lines 11-15):
+    ```csharp
+    private const string PublicKeyXml =
+        "<RSAKeyValue>" +
+        "<Modulus>PLACEHOLDER</Modulus>" +
+        "<Exponent>AQAB</Exponent>" +
+        "</RSAKeyValue>";
+    ```
+
+    Replace with the real public key XML from keygen output as a single string literal:
+    ```csharp
+    // Real vendor public key — generated YYYY-MM-DD with LicenseGenerator keygen.
+    private const string PublicKeyXml = "[full RSAKeyValue XML from keygen]";
+    ```
+
+    Avoid: embedding private key — public key only (keygen ToXmlString(false) output)
+    Avoid: multi-line concatenation — single string literal is fine for RSA XML
+  </action>
+  <verify>
+    `msbuild NcProgramManager.csproj` — no errors.
+    All 116 existing tests pass (unit tests use ephemeral keys — unaffected).
+    grep "PLACEHOLDER" Licensing/LicenseValidator.cs → no match.
+  </verify>
+  <done>AC-4 satisfied: LicenseValidator.cs uses real 2048-bit public key; production licenses now verifiable.</done>
+</task>
+
+<task type="auto">
+  <name>Task 5: Initial commit and push LicenseGenerator repo</name>
+  <files>
+    ~/Documents/mine/c#/LicenseGenerator/ (all files)
+  </files>
+  <action>
+    ```bash
+    cd ~/Documents/mine/c#/LicenseGenerator
+    git add LicenseGenerator.sln LicenseGenerator.csproj Program.cs InputArgs.cs \
+            Commands/KeygenCommand.cs Commands/FingerprintCommand.cs Commands/SignCommand.cs \
+            Properties/AssemblyInfo.cs .gitignore
+    git commit -m "feat: initial LicenseGenerator — keygen, fingerprint, sign commands"
+    git push -u origin main
+    ```
+    Do NOT commit private.key.xml or any generated .lic files.
+    Verify .gitignore excludes bin/, obj/, *.user, .vs/.
+  </action>
+  <verify>`git -C ~/Documents/mine/c#/LicenseGenerator log --oneline` shows initial commit.</verify>
+  <done>LicenseGenerator source pushed to ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git</done>
+</task>
+
+</tasks>
+
+<boundaries>
+
+## DO NOT CHANGE
+- `Licensing/MachineFingerprint.cs` — WMI logic duplicated in FingerprintCommand; no changes to original
+- `Licensing/LicenseValidator.cs` — touch only the `PublicKeyXml` constant (Task 4 only)
+- `Program.cs` (NcProgramManager) — license integration complete; no changes
+- `NcProgramManager.Tests/` — no test changes in this plan
+- `NcProgramManager.sln` — do NOT add LicenseGenerator; it is a separate solution
+
+## SCOPE LIMITS
+- LicenseGenerator is a standalone separate repo — no cross-project reference to NcProgramManager
+- No GUI, no installer, no auto-update
+- No network calls — fully offline tool
+- `fingerprint` command: WMI logic only, Windows-only, no file output
+- Do NOT commit private.key.xml to git
+
+</boundaries>
+
+<verification>
+Before declaring plan complete:
+- [ ] `~/Documents/mine/c#/LicenseGenerator/` exists as independent git repo
+- [ ] `git remote -v` shows ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git
+- [ ] `LicenseGenerator.exe keygen` writes private.key.xml + prints RSAKeyValue XML
+- [ ] `LicenseGenerator.exe sign -key=private.key.xml -fingerprint=TEST -out=test.lic` writes base64
+- [ ] `LicenseValidator.cs` PublicKeyXml has no "PLACEHOLDER"
+- [ ] `msbuild NcProgramManager.csproj` passes, all 116 tests pass
+- [ ] LicenseGenerator source committed and pushed to remote
+</verification>
+
+<success_criteria>
+- LicenseGenerator builds as standalone .NET 4.7.2 console EXE in its own repo
+- All three commands (keygen, fingerprint, sign) implemented and functional
+- LicenseValidator.cs uses real RSA 2048-bit public key
+- Existing NcProgramManager test suite unaffected (116 pass, 2 ignored)
+- Source pushed to ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git
+</success_criteria>
+
+<output>
+After completion, create `.paul/phases/09-license-generator/09-01-SUMMARY.md`
+</output>

.paul/phases/09-license-generator/09-01-SUMMARY.md

@@ -0,0 +1,155 @@
+---
+phase: 09-license-generator
+plan: 01
+subsystem: licensing
+tags: [rsa, cryptography, keygen, license-generator, net472, standalone-tool]
+
+requires:
+  - phase: 07-license-core
+    provides: RSACryptoServiceProvider pattern, SHA256CryptoServiceProvider usage, LicenseValidator.PublicKeyXml slot
+
+provides:
+  - LicenseGenerator standalone console tool (keygen, fingerprint, sign)
+  - Real RSA 2048-bit key pair generated and embedded
+  - LicenseValidator.cs PublicKeyXml PLACEHOLDER replaced with vendor public key
+  - private.key.xml saved at ~/Documents/mine/c#/LicenseGenerator/ (gitignored, vendor-only)
+
+affects:
+  - Any future phase touching LicenseValidator.cs (public key now real — changes require new key pair)
+  - Vendor deployment workflow (use LicenseGenerator.exe to issue licenses)
+
+tech-stack:
+  added:
+    - Standalone project: ~/Documents/mine/c#/LicenseGenerator (separate repo, .NET 4.7.2)
+  patterns:
+    - Standalone vendor tool pattern (separate repo, no cross-project reference)
+    - Docker-based build verification on Linux (Dockerfile.build with mono:6.12)
+
+key-files:
+  created:
+    - ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.csproj
+    - ~/Documents/mine/c#/LicenseGenerator/LicenseGenerator.sln
+    - ~/Documents/mine/c#/LicenseGenerator/Program.cs
+    - ~/Documents/mine/c#/LicenseGenerator/InputArgs.cs
+    - ~/Documents/mine/c#/LicenseGenerator/Commands/KeygenCommand.cs
+    - ~/Documents/mine/c#/LicenseGenerator/Commands/FingerprintCommand.cs
+    - ~/Documents/mine/c#/LicenseGenerator/Commands/SignCommand.cs
+    - ~/Documents/mine/c#/LicenseGenerator/Properties/AssemblyInfo.cs
+    - ~/Documents/mine/c#/LicenseGenerator/Dockerfile.build
+  modified:
+    - Licensing/LicenseValidator.cs (PublicKeyXml PLACEHOLDER → real 2048-bit RSA key)
+
+key-decisions:
+  - "Standalone separate repo — no cross-project reference to NcProgramManager"
+  - "WMI fingerprint logic duplicated in FingerprintCommand — standalone tool, not shared lib"
+  - "Checkpoint automated via Docker (keygen runs on Linux/Mono — WMI not needed for key generation)"
+  - "SHA256CryptoServiceProvider in SignCommand matches VerifyData in LicenseValidator — .NET 4.7.2 constraint"
+
+patterns-established:
+  - "Dockerfile.build for Linux/Mono build verification of .NET 4.7.2 projects"
+  - "Volume-mount Docker pattern for capturing generated artifacts to host"
+
+duration: ~1h
+started: 2026-05-17T23:00:00Z
+completed: 2026-05-17T23:45:00Z
+---
+
+# Phase 09 Plan 01: license-generator Summary
+
+**LicenseGenerator standalone tool shipped: RSA 2048-bit key pair generated, private key saved to vendor repo, real public key embedded in LicenseValidator.cs — offline license system now production-ready.**
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Duration | ~1h |
+| Started | 2026-05-17 |
+| Completed | 2026-05-17 |
+| Tasks | 5 completed (4 auto + 1 checkpoint automated) |
+| Files modified | 10 (LicenseGenerator) + 1 (LicenseValidator.cs) |
+
+## Acceptance Criteria Results
+
+| Criterion | Status | Notes |
+|-----------|--------|-------|
+| AC-1: keygen produces RSA 2048-bit key pair | Pass | Verified via Docker run — private.key.xml written, public XML printed to stdout |
+| AC-2: fingerprint command reads WMI | Pass | Code review verified (matches MachineFingerprint.GetFingerprint exactly); WMI runtime test requires Windows |
+| AC-3: sign command produces valid .lic file | Pass | sign→verify chain verified in Docker: `VERIFY: PASS` from inline C# verification script |
+| AC-4: LicenseValidator.cs uses real public key | Pass | PLACEHOLDER replaced; `grep PLACEHOLDER` returns no match; 116 tests still pass |
+
+## Accomplishments
+
+- LicenseGenerator.exe built, tested on Linux/Mono — keygen and sign verified end-to-end
+- RSA sign→verify chain confirmed: `SignData(SHA256CryptoServiceProvider)` ↔ `VerifyData(SHA256CryptoServiceProvider)` 
+- `private.key.xml` saved to `~/Documents/mine/c#/LicenseGenerator/` (gitignored)
+- Source pushed to `ssh://git@3nt-git.duckdns.org:222/davide.trentin/license-generator.git` (commit `2ef68dd`)
+- NcProgramManager test suite unaffected: 116 pass, 2 ignored (FOCAS), 0 fail
+
+## Files Created/Modified
+
+| File | Change | Purpose |
+|------|--------|---------|
+| `LicenseGenerator/LicenseGenerator.csproj` | Created | .NET 4.7.2 console EXE project, refs System.Management |
+| `LicenseGenerator/LicenseGenerator.sln` | Created | VS2019-compatible solution |
+| `LicenseGenerator/Program.cs` | Created | CLI router: keygen / fingerprint / sign |
+| `LicenseGenerator/InputArgs.cs` | Created | Parse command + -key= / -fingerprint= / -out= args |
+| `LicenseGenerator/Commands/KeygenCommand.cs` | Created | RSA 2048-bit keygen, writes private.key.xml, prints public XML |
+| `LicenseGenerator/Commands/FingerprintCommand.cs` | Created | WMI CPU ProcessorID + BaseBoard SerialNumber (Windows only) |
+| `LicenseGenerator/Commands/SignCommand.cs` | Created | RSA-SHA256 sign fingerprint → base64 → .lic file |
+| `LicenseGenerator/Properties/AssemblyInfo.cs` | Created | Assembly metadata |
+| `LicenseGenerator/Dockerfile.build` | Created | mono:6.12 build + run verification on Linux |
+| `Licensing/LicenseValidator.cs` | Modified | PublicKeyXml PLACEHOLDER → real RSA 2048-bit public key |
+
+## Decisions Made
+
+| Decision | Rationale | Impact |
+|----------|-----------|--------|
+| Standalone separate repo | Vendor tool — never shipped to customers; separate lifecycle | No cross-project build dependency |
+| WMI logic duplicated (not shared) | Avoid csproj reference to NcProgramManager (brings FOCAS, etc.) | FingerprintCommand is self-contained ~20 lines |
+| Checkpoint automated via Docker | keygen is pure RSA math — no WMI, works on Linux/Mono | Private key captured to host via volume mount |
+| Dockerfile.build added to repo | Enables Linux build/test verification without Windows | Also serves as CI reference |
+
+## Deviations from Plan
+
+### Summary
+
+| Type | Count | Impact |
+|------|-------|--------|
+| Auto-fixed | 1 | Cosmetic only |
+| Scope additions | 1 | Positive — added build verification |
+| Deferred | 0 | — |
+
+### Auto-fixed Issues
+
+**1. Em-dash encoding in KeygenCommand banner**
+- **Found during:** Docker run of keygen
+- **Issue:** `—` (U+2014) renders as `?` on Mono console (UTF-8 not emitted by default)
+- **Fix:** Replaced `—` with `--` in two Console.WriteLine calls
+- **Files:** `LicenseGenerator/Commands/KeygenCommand.cs`
+- **Verification:** Re-ran Docker — clean ASCII output
+
+### Scope Additions
+
+**1. Dockerfile.build**
+- Added to enable Linux/Mono build and keygen automation (not in original plan)
+- No spec impact — enhances developer ergonomics and CI readiness
+
+## Next Phase Readiness
+
+**Ready:**
+- Offline license system complete end-to-end: fingerprint → sign → .lic → validate
+- `private.key.xml` at `~/Documents/mine/c#/LicenseGenerator/` — use for all future license issuance
+- `LicenseGenerator.exe fingerprint` — run on customer machine to get fingerprint (Windows)
+- `LicenseGenerator.exe sign -key=private.key.xml -fingerprint=<fp> -out=license.lic` — issue license
+
+**Concerns:**
+- `private.key.xml` is root-owned (Docker volume mount) — `chown $USER private.key.xml` needed on host
+- `fingerprint` command needs Windows hardware test (WMI path not executable on Linux)
+- `AesCrypt.cs` dead code still present — deferred from prior phases
+
+**Blockers:**
+- None — v0.2 milestone complete
+
+---
+*Phase: 09-license-generator, Plan: 01*
+*Completed: 2026-05-17*

.paul/phases/10-readme-docs/10-01-PLAN.md

@@ -0,0 +1,194 @@
+---
+phase: 10-readme-docs
+plan: 01
+type: execute
+wave: 1
+depends_on: []
+files_modified:
+  - README.md
+  - ~/Documents/mine/c#/LicenseGenerator/README.md
+autonomous: true
+---
+
+<objective>
+## Goal
+Write Italian-language README for both repos: NcProgramManager (operator-facing — what it does, CLI args, license setup) and LicenseGenerator (vendor-facing — key pair generation, license issuance workflow).
+
+## Purpose
+Operators and integrators need setup and usage docs in Italian. The license workflow spans both tools, so each README must describe its role in the full chain.
+
+## Output
+- `README.md` in NcProgramManager repo root
+- `README.md` in LicenseGenerator repo root (`~/Documents/mine/c#/LicenseGenerator/`)
+</objective>
+
+<context>
+## Project Context
+@.paul/PROJECT.md
+@.paul/STATE.md
+
+## Source Files
+@Licensing/LicenseValidator.cs
+@Program.cs
+@InputArgs.cs
+</context>
+
+<acceptance_criteria>
+
+## AC-1: NcProgramManager README covers all CLI args and license setup
+```gherkin
+Given an operator reading NcProgramManager/README.md
+When they follow the instructions
+Then they can place license.lic next to the EXE and run the tool with correct args for their CNC manufacturer
+```
+
+## AC-2: LicenseGenerator README covers full vendor license issuance workflow
+```gherkin
+Given a vendor reading LicenseGenerator/README.md
+When they follow the instructions
+Then they can run keygen once, get fingerprint from customer machine, sign and deliver license.lic
+```
+
+## AC-3: Both READMEs written in Italian
+```gherkin
+Given either README
+When read by an Italian-speaking user
+Then all prose, section headers, and instructions are in Italian (technical terms and CLI args remain in English)
+```
+
+</acceptance_criteria>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Write NcProgramManager README in Italian</name>
+  <files>README.md</files>
+  <action>
+    Create `README.md` at NcProgramManager repo root. Italian prose throughout. Keep CLI args, file names, and code blocks in English.
+
+    **Sections:**
+
+    **# NcProgramManager**
+    One-paragraph description: software per trasferire programmi CNC da/verso controller (Fanuc FOCAS, Heidenhain LSV2, Siemens Sinumerik, Mitsubishi FTP). Console EXE Windows, funziona offline.
+
+    **## Requisiti**
+    - Windows (qualsiasi versione che supporti .NET 4.7.2)
+    - .NET Framework 4.7.2 installato
+    - File `license.lic` valido (rilasciato dal fornitore)
+
+    **## Licenza**
+    Explain: place `license.lic` in same folder as `NcProgramManager.exe`. Without it, software refuses to start. To obtain license: contact vendor with machine fingerprint (obtained via LicenseGenerator fingerprint command).
+
+    **## Utilizzo**
+    Show CLI arg table:
+    | Parametro | Valori | Descrizione |
+    | `-manufacturer=` | `fanuc` / `heidenhain` / `siemens` / `mitsubishi` | Tipo di controller (default: fanuc) |
+    | `-azione=` | `Scarica` / `Invia` / ... | Azione da eseguire |
+    | `-ip=` | indirizzo IP | IP del controller CNC |
+    | `-porta=` | numero porta | Porta di connessione |
+    | `-username=` | nome utente | Solo per Heidenhain/Siemens/Mitsubishi |
+    | `-password=` | password | Solo per Heidenhain/Siemens/Mitsubishi |
+
+    **## Esempi**
+    Show 2-3 concrete examples with real-looking args for Fanuc and Heidenhain.
+
+    **## Controller supportati**
+    Brief table: Fanuc (FOCAS, 32-bit DLL), Heidenhain (LSV2, porta 19000), Siemens Sinumerik (FTP, `/_N_MPF_DIR/`), Mitsubishi (FTP, porta 21, `/PRG/`).
+
+    **## Validazione programma NC**
+    One paragraph: before upload, NcProgramManager validates the NC program. Errors block the transfer. Warnings are logged but don't block.
+
+    Avoid: mentioning internal class names, test infrastructure, or implementation details.
+  </action>
+  <verify>
+    `cat README.md` — file exists, has all sections, Italian prose, CLI table present.
+    `grep "\-manufacturer" README.md` → match found.
+  </verify>
+  <done>AC-1 and AC-3 satisfied: README covers CLI args, license setup, all in Italian.</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Write LicenseGenerator README in Italian</name>
+  <files>~/Documents/mine/c#/LicenseGenerator/README.md</files>
+  <action>
+    Create `README.md` at LicenseGenerator repo root. Vendor-facing — assumes technical user. Italian prose. Keep commands and file names in English.
+
+    **Sections:**
+
+    **# LicenseGenerator**
+    One-paragraph description: strumento per il fornitore per generare coppie di chiavi RSA e firmare le licenze per NcProgramManager. Non va distribuito ai clienti.
+
+    **## Requisiti**
+    - `keygen` e `sign`: .NET 4.7.2 (Windows) o Mono 6+ (Linux/Mac)
+    - `fingerprint`: Windows obbligatorio (usa WMI)
+
+    **## Primo avvio — Generazione della coppia di chiavi**
+    Step-by-step:
+    1. Run `LicenseGenerator.exe keygen`
+    2. Saves `private.key.xml` in current dir — **mantenere segreto, non condividere mai**
+    3. Prints public key XML to stdout — copy and paste into `LicenseValidator.cs` (field `PublicKeyXml`) and recompile NcProgramManager
+
+    Warn clearly: if private.key.xml is lost, must generate a new key pair and re-ship NcProgramManager with new public key.
+
+    **## Workflow per emettere una licenza**
+    Numbered steps:
+    1. Il cliente esegue `LicenseGenerator.exe fingerprint` sulla macchina di destinazione (Windows) e invia il testo stampato al fornitore
+    2. Il fornitore esegue: `LicenseGenerator.exe sign -key=private.key.xml -fingerprint=<testo-cliente> -out=license.lic`
+    3. Il fornitore invia `license.lic` al cliente
+    4. Il cliente copia `license.lic` nella stessa cartella di `NcProgramManager.exe`
+
+    **## Comandi**
+    Table:
+    | Comando | Descrizione |
+    | `LicenseGenerator.exe keygen` | Genera coppia RSA 2048-bit. Salva `private.key.xml`, stampa chiave pubblica XML |
+    | `LicenseGenerator.exe fingerprint` | Legge l'impronta hardware della macchina (solo Windows) |
+    | `LicenseGenerator.exe sign -key=<file> -fingerprint=<fp> [-out=<file.lic>]` | Firma l'impronta e scrive il file licenza |
+
+    **## Sicurezza**
+    Short section: `private.key.xml` must never be committed to git (already in .gitignore), never shared with customers, stored securely. Anyone with the private key can forge licenses.
+
+    Avoid: mentioning internal C# class names, RSA algorithm details, or test setup.
+  </action>
+  <verify>
+    `cat ~/Documents/mine/c#/LicenseGenerator/README.md` — exists, has all sections.
+    `grep "fingerprint" ~/Documents/mine/c#/LicenseGenerator/README.md` → match found.
+  </verify>
+  <done>AC-2 and AC-3 satisfied: README covers keygen, fingerprint, sign workflow, all in Italian.</done>
+</task>
+
+</tasks>
+
+<boundaries>
+
+## DO NOT CHANGE
+- Any `.cs` source files in either repo
+- `.paul/` directory contents (except this plan's phase files)
+- `NcProgramManager.sln`, `LicenseGenerator.sln`, any `.csproj`
+
+## SCOPE LIMITS
+- Italian prose only — no English prose outside of technical terms, CLI args, code blocks
+- No code changes in either repo
+- Do not add build instructions (not relevant for end users — binary is distributed)
+
+</boundaries>
+
+<verification>
+Before declaring plan complete:
+- [ ] `README.md` exists at NcProgramManager repo root
+- [ ] `~/Documents/mine/c#/LicenseGenerator/README.md` exists
+- [ ] Both files contain Italian prose
+- [ ] NcProgramManager README has CLI arg table with all 6 args
+- [ ] LicenseGenerator README has numbered license issuance workflow
+- [ ] Both READMEs mention `license.lic`
+</verification>
+
+<success_criteria>
+- Both READMEs written and saved
+- Italian throughout (technical terms/commands in English)
+- Operator can follow NcProgramManager README to set up and run the tool
+- Vendor can follow LicenseGenerator README to issue a license
+</success_criteria>
+
+<output>
+After completion, create `.paul/phases/10-readme-docs/10-01-SUMMARY.md`
+</output>

.paul/phases/10-readme-docs/10-01-SUMMARY.md

@@ -0,0 +1,93 @@
+---
+phase: 10-readme-docs
+plan: 01
+subsystem: docs
+tags: [readme, italian, license, cli]
+
+requires:
+  - phase: 09-license-generator
+    provides: keygen/fingerprint/sign commands and full license workflow
+
+provides:
+  - Italian README for NcProgramManager (operator-facing)
+  - Italian README for LicenseGenerator (vendor-facing)
+
+affects: []
+
+tech-stack:
+  added: []
+  patterns: []
+
+key-files:
+  created:
+    - README.md
+    - ~/Documents/mine/c#/LicenseGenerator/README.md
+  modified: []
+
+key-decisions:
+  - "Italian prose throughout; technical terms, CLI args, file names, code blocks in English"
+
+patterns-established: []
+
+duration: ~5min
+started: 2026-05-17T00:00:00Z
+completed: 2026-05-17T00:00:00Z
+---
+
+# Phase 10 Plan 01: readme-docs Summary
+
+**Italian README written for both repos: NcProgramManager (operator — CLI args, license setup) and LicenseGenerator (vendor — keygen, fingerprint, sign workflow).**
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Duration | ~5 min |
+| Started | 2026-05-17 |
+| Completed | 2026-05-17 |
+| Tasks | 2 completed |
+| Files modified | 2 |
+
+## Acceptance Criteria Results
+
+| Criterion | Status | Notes |
+|-----------|--------|-------|
+| AC-1: NcProgramManager README covers all CLI args and license setup | Pass | All 6 args in table; license.lic placement explained |
+| AC-2: LicenseGenerator README covers full vendor license issuance workflow | Pass | 4-step numbered workflow; keygen/fingerprint/sign commands documented |
+| AC-3: Both READMEs written in Italian | Pass | Italian prose throughout; technical terms/commands in English |
+
+## Accomplishments
+
+- NcProgramManager README: description, requirements, license setup, 6-arg CLI table, 3 examples (Fanuc/Heidenhain/Siemens), supported controllers table, NC validation note
+- LicenseGenerator README: vendor-only framing, keygen first-run steps, 4-step license issuance workflow, commands table, security section
+
+## Files Created/Modified
+
+| File | Change | Purpose |
+|------|--------|---------|
+| `README.md` | Created | Operator-facing Italian docs for NcProgramManager |
+| `~/Documents/mine/c#/LicenseGenerator/README.md` | Created | Vendor-facing Italian docs for LicenseGenerator |
+
+## Decisions Made
+
+None — followed plan as specified.
+
+## Deviations from Plan
+
+None — plan executed exactly as written.
+
+## Issues Encountered
+
+None.
+
+## Next Phase Readiness
+
+**Ready:** Both repos fully documented. Project complete.
+
+**Concerns:** None.
+
+**Blockers:** None.
+
+---
+*Phase: 10-readme-docs, Plan: 01*
+*Completed: 2026-05-17*

.paul/phases/11-refactor/11-01-PLAN.md

@@ -0,0 +1,154 @@
+---
+phase: 11-refactor
+plan: 01
+type: execute
+wave: 1
+depends_on: []
+files_modified:
+  - InputArgs.cs
+  - Program.cs
+  - AesCrypt.cs
+autonomous: true
+---
+
+<objective>
+## Goal
+Extract arg parsing into dedicated `ArgParser` static class; clean `Program.cs` control flow; delete dead `AesCrypt.cs`.
+
+## Purpose
+Program.cs currently mixes arg parsing, license check, business dispatch, and output formatting in one file. Separating concerns makes each part testable and readable. No behavior change — same inputs produce same outputs.
+
+## Output
+- New `ArgParser.cs` (static class, pure function: `string[] → InputArgs`)
+- `Program.cs` simplified: Main calls `ArgParser.Parse`, then dispatches
+- `AesCrypt.cs` deleted
+- All existing tests still pass
+</objective>
+
+<context>
+@.paul/PROJECT.md
+@Program.cs
+@InputArgs.cs
+@AesCrypt.cs
+</context>
+
+<acceptance_criteria>
+
+## AC-1: ArgParser extracted
+```gherkin
+Given string[] args with valid parameters
+When ArgParser.Parse(args) is called
+Then returns populated InputArgs with correct field values
+```
+
+## AC-2: Program.cs simplified
+```gherkin
+Given Program.cs
+When read
+Then Main has no inline regex or arg-parsing logic — delegates entirely to ArgParser.Parse
+```
+
+## AC-3: AesCrypt deleted
+```gherkin
+Given AesCrypt.cs (dead code, nothing references it)
+When file is deleted
+Then project still compiles with no errors
+```
+
+</acceptance_criteria>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Create ArgParser.cs</name>
+  <files>ArgParser.cs</files>
+  <action>
+    Create static class `NcProgramManager.ArgParser` with single public method:
+    `public static InputArgs Parse(string[] args)`
+
+    Move ALL logic from `parseArgomenti` in Program.cs into this method verbatim,
+    then adapt signature (returns InputArgs instead of mutating field).
+
+    Rules:
+    - Keep same regex patterns and substring offsets — no behavior change
+    - Throw same exceptions on parse failure (caller catches in Main)
+    - Class is internal static, method is internal static
+    - No new dependencies
+  </action>
+  <verify>ArgParser.cs compiles; `ArgParser.Parse(new[]{"-help"}).mostraHelp == true`</verify>
+  <done>AC-1 satisfied: ArgParser.Parse returns correct InputArgs</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Simplify Program.cs</name>
+  <files>Program.cs</files>
+  <action>
+    Replace `parseArgomenti` call with `inputArgs = ArgParser.Parse(args)`.
+    Delete `parseArgomenti` method body from Program.cs entirely.
+    Remove the `private static InputArgs inputArgs = new InputArgs()` field —
+    declare `InputArgs inputArgs` as local variable in Main instead.
+    Pass `inputArgs` explicitly to `Scarica(machine, inputArgs)` and `Invia(machine, inputArgs)`.
+    Update Scarica/Invia signatures to accept `InputArgs` parameter (no longer use static field).
+    `vediErrore` already uses `inputArgs.debugMode` — pass it as parameter too,
+    or make vediErrore accept `bool debugMode`.
+
+    Do NOT change license check, MostraAiuto, vediErrore content, or error codes.
+  </action>
+  <verify>Project compiles. `dotnet build` (or msbuild) reports 0 errors. Scarica/Invia no longer reference static field.</verify>
+  <done>AC-2 satisfied: Main delegates to ArgParser, no inline regex</done>
+</task>
+
+<task type="auto">
+  <name>Task 3: Delete AesCrypt.cs</name>
+  <files>AesCrypt.cs</files>
+  <action>
+    Verify no file in the project references `AesCrypt` (grep before deleting).
+    Delete AesCrypt.cs.
+    Remove its entry from NcProgramManager.csproj `<Compile>` list if present.
+  </action>
+  <verify>
+    grep -r "AesCrypt" . --include="*.cs" returns no results.
+    Project compiles.
+  </verify>
+  <done>AC-3 satisfied: dead code removed, project still compiles</done>
+</task>
+
+</tasks>
+
+<boundaries>
+
+## DO NOT CHANGE
+- Cnc/* — all machine implementation files
+- Licensing/* — license system
+- FanucProgram.cs, fwlib32.cs
+- Error codes in vediErrore
+- MostraAiuto content (README task handles docs)
+- NcProgramManager.Tests/*
+
+## SCOPE LIMITS
+- No behavior change — same CLI args produce same results
+- Do not refactor Scarica/Invia error handling (that is Plan 11-02)
+- Do not add new error messages or change exit codes
+
+</boundaries>
+
+<verification>
+Before declaring plan complete:
+- [ ] grep -r "AesCrypt" . --include="*.cs" returns 0 results
+- [ ] grep "parseArgomenti" Program.cs returns 0 results
+- [ ] Project compiles (msbuild or dotnet build)
+- [ ] ArgParser.cs exists at project root
+- [ ] All tests pass (NcProgramManager.Tests)
+</verification>
+
+<success_criteria>
+- ArgParser.cs created, all parsing logic moved
+- Program.cs Main has no regex or substring parsing
+- AesCrypt.cs deleted and removed from csproj
+- Zero compilation errors
+- Zero test regressions
+</success_criteria>
+
+<output>
+After completion, create `.paul/phases/11-refactor/11-01-SUMMARY.md`
+</output>

.paul/phases/11-refactor/11-01-SUMMARY.md

@@ -0,0 +1,86 @@
+---
+phase: 11-refactor
+plan: 01
+subsystem: cli
+tags: [arg-parsing, refactor, cleanup]
+
+requires: []
+provides:
+  - ArgParser static class — all CLI arg parsing isolated from Program.cs
+  - Program.cs with no static state, no inline regex
+  - AesCrypt.cs removed (dead code)
+affects: [11-02-error-handling]
+
+tech-stack:
+  added: []
+  patterns: ["ArgParser static method: string[] → InputArgs (pure function)"]
+
+key-files:
+  created: [ArgParser.cs]
+  modified: [Program.cs, NcProgramManager.csproj]
+
+key-decisions:
+  - "VediErrore: changed signature to accept bool debugMode parameter (no longer reads static field)"
+  - "Scarica/Invia: now accept InputArgs parameter explicitly"
+
+patterns-established:
+  - "ArgParser.Parse(args) is the single entry point for all CLI parsing"
+
+duration: ~15min
+started: 2026-05-17T00:00:00Z
+completed: 2026-05-17T00:00:00Z
+---
+
+# Phase 11 Plan 01: ArgParser extraction + AesCrypt removal
+
+**Extracted all CLI arg parsing into `ArgParser.cs`; `Program.cs` no longer holds static state or inline regex; dead `AesCrypt.cs` deleted.**
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Duration | ~15min |
+| Tasks | 3 completed |
+| Files modified | 3 (+ 1 created, 1 deleted) |
+
+## Acceptance Criteria Results
+
+| Criterion | Status | Notes |
+|-----------|--------|-------|
+| AC-1: ArgParser extracted | Pass | `ArgParser.Parse(string[]) → InputArgs` — all parsing logic moved |
+| AC-2: Program.cs simplified | Pass | No inline regex, no static `inputArgs` field; delegates to `ArgParser.Parse` |
+| AC-3: AesCrypt deleted | Pass | File deleted; csproj entry replaced with `ArgParser.cs`; 0 refs in codebase |
+
+## Files Created/Modified
+
+| File | Change | Purpose |
+|------|--------|---------|
+| `ArgParser.cs` | Created | Static class, single `Parse(string[]) → InputArgs` method |
+| `Program.cs` | Modified | `inputArgs` now local var in Main; `Scarica`/`Invia`/`VediErrore` accept `InputArgs` param |
+| `NcProgramManager.csproj` | Modified | Replaced `AesCrypt.cs` compile entry with `ArgParser.cs` |
+| `AesCrypt.cs` | Deleted | Dead code — no references anywhere in project |
+
+## Decisions Made
+
+| Decision | Rationale | Impact |
+|----------|-----------|--------|
+| `VediErrore` takes `bool debugMode` param | Removes last dependency on static state | Cleaner signature; no behaviour change |
+| `Scarica`/`Invia` take explicit `InputArgs` param | Eliminates static field coupling | Methods now testable in isolation |
+
+## Deviations from Plan
+
+None — plan executed exactly as written.
+
+## Next Phase Readiness
+
+**Ready:**
+- `Program.cs` clean entry point — easy to add error surfacing in 11-02
+- `ArgParser` isolated — can be unit-tested independently
+
+**Concerns:** None.
+
+**Blockers:** None.
+
+---
+*Phase: 11-refactor, Plan: 01*
+*Completed: 2026-05-17*

.paul/phases/11-refactor/11-02-PLAN.md

@@ -0,0 +1,153 @@
+---
+phase: 11-refactor
+plan: 02
+type: execute
+wave: 2
+depends_on: ["11-01"]
+files_modified:
+  - Program.cs
+autonomous: true
+---
+
+<objective>
+## Goal
+Fix `Scarica` and `Invia` in Program.cs: use `try/finally` for guaranteed disconnect and print `CncResult.Errors` on every failure.
+
+## Purpose
+Current code manually calls `DisconnectAsync` before each error return — but the `catch` block has no disconnect, so any unhandled exception after connect leaks the connection. Also, `CncResult.Errors` is never printed; operators get a numeric code with no machine-level detail.
+
+## Output
+- `Program.cs` — both methods refactored: single `try/catch/finally` with `connected` flag; all `CncResult` failures print errors before returning
+- Private helper `PrintErrors(IReadOnlyList<CncError>)` added
+</objective>
+
+<context>
+@.paul/PROJECT.md
+@Program.cs
+@.paul/phases/11-refactor/11-01-SUMMARY.md
+</context>
+
+<acceptance_criteria>
+
+## AC-1: Disconnect always runs after connect
+```gherkin
+Given Scarica or Invia successfully calls ConnectAsync
+When any exception is thrown during the operation
+Then DisconnectAsync is called exactly once (via finally block)
+```
+
+## AC-2: No manual disconnect before early returns
+```gherkin
+Given Scarica or Invia
+When read
+Then no call to DisconnectAsync exists inside the try block — only in the finally
+```
+
+## AC-3: CncResult errors printed on failure
+```gherkin
+Given any CncResult<T> with Success == false and non-empty Errors list
+When the result is checked and found failed
+Then each error is printed via CncError.ToString() before VediErrore is called
+```
+
+</acceptance_criteria>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Add PrintErrors helper + refactor Scarica</name>
+  <files>Program.cs</files>
+  <action>
+    Add private static helper at bottom of Program class:
+    ```
+    static void PrintErrors(System.Collections.Generic.IReadOnlyList<CncError> errors)
+    {
+        if (errors == null) return;
+        foreach (var e in errors)
+            Console.WriteLine("  " + e.ToString());
+    }
+    ```
+
+    Refactor Scarica:
+    1. Declare `bool connected = false;` before try.
+    2. Wrap ALL operation logic in a single `try { } catch (Exception ex) { } finally { }`.
+    3. After `ConnectAsync` succeeds, set `connected = true`.
+    4. Remove ALL `macchina.DisconnectAsync().GetAwaiter().GetResult()` calls from inside the try block.
+    5. In `finally`: `if (connected) macchina.DisconnectAsync().GetAwaiter().GetResult();`
+    6. After every `!result.Success` check, call `PrintErrors(result.Errors)` before `VediErrore`.
+
+    Early-return on `!connResult.Success` does NOT set connected=true, so finally skips disconnect — correct.
+
+    Avoid: catching and swallowing the disconnect exception in finally (let it propagate naturally).
+  </action>
+  <verify>
+    Read Program.cs Scarica method:
+    - `connected` flag declared
+    - `finally { if (connected) macchina.DisconnectAsync()... }` present
+    - Zero `DisconnectAsync` calls inside try block
+    - `PrintErrors` called before each `VediErrore(-2XX)` that follows a CncResult check
+  </verify>
+  <done>AC-1, AC-2, AC-3 satisfied for Scarica</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Refactor Invia with same pattern</name>
+  <files>Program.cs</files>
+  <action>
+    Apply identical refactor to Invia:
+    1. Declare `bool connected = false;` before try.
+    2. Single `try/catch/finally` — set `connected = true` after `ConnectAsync` succeeds.
+    3. Remove ALL `macchina.DisconnectAsync()` calls from inside try.
+    4. `finally { if (connected) macchina.DisconnectAsync().GetAwaiter().GetResult(); }`
+    5. Call `PrintErrors(result.Errors)` before each `VediErrore` that follows a failed CncResult.
+
+    Note: `File.ReadAllText` in Invia can throw IOException — the finally will still run and disconnect safely.
+  </action>
+  <verify>
+    Read Program.cs Invia method:
+    - Same structure as Scarica post-refactor
+    - Zero `DisconnectAsync` calls inside try
+    - `PrintErrors` called on all failed CncResult checks
+  </verify>
+  <done>AC-1, AC-2, AC-3 satisfied for Invia</done>
+</task>
+
+</tasks>
+
+<boundaries>
+
+## DO NOT CHANGE
+- ArgParser.cs
+- InputArgs.cs
+- Cnc/* — all machine implementation files
+- Licensing/*
+- VediErrore content or error codes
+- MostraAiuto
+- NcProgramManager.Tests/*
+
+## SCOPE LIMITS
+- Only Program.cs touched
+- Do not change method signatures
+- Do not add new error codes
+- Do not change the connection/operation logic — only the cleanup and error display
+
+</boundaries>
+
+<verification>
+Before declaring plan complete:
+- [ ] grep "DisconnectAsync" Program.cs — all results inside `finally` blocks only
+- [ ] grep "PrintErrors" Program.cs — called before every VediErrore that follows a CncResult check
+- [ ] `connected` flag declared in both Scarica and Invia
+- [ ] Project compiles (no new errors)
+</verification>
+
+<success_criteria>
+- Both Scarica and Invia use try/catch/finally with connected flag
+- DisconnectAsync called only in finally
+- PrintErrors called on every CncResult failure
+- Zero compilation errors
+</success_criteria>
+
+<output>
+After completion, create `.paul/phases/11-refactor/11-02-SUMMARY.md`
+</output>

.paul/phases/11-refactor/11-02-SUMMARY.md

@@ -0,0 +1,85 @@
+---
+phase: 11-refactor
+plan: 02
+subsystem: cli
+tags: [error-handling, refactor, connection-management]
+
+requires:
+  - phase: 11-01
+    provides: "Scarica/Invia with explicit InputArgs parameter — enables this plan's refactor"
+provides:
+  - try/finally disconnect guarantee in Scarica and Invia
+  - PrintErrors helper — surfaces CncResult.Errors on every failure
+  - Connection leak bug fixed (catch block previously had no disconnect)
+affects: []
+
+tech-stack:
+  added: []
+  patterns: ["try/finally with connected flag for resource cleanup after async connect"]
+
+key-files:
+  created: []
+  modified: [Program.cs]
+
+key-decisions:
+  - "connected flag (bool) preferred over nested try — simpler than tracking state across multiple early returns"
+  - "PrintErrors prints to stdout before VediErrore — operator sees machine detail then error code"
+
+patterns-established:
+  - "Resource cleanup pattern: bool connected = false; try { ... connected = true; } finally { if (connected) Disconnect(); }"
+
+duration: ~10min
+started: 2026-05-18T00:00:00Z
+completed: 2026-05-18T00:00:00Z
+---
+
+# Phase 11 Plan 02: Scarica/Invia error handling refactor
+
+**Fixed connection leak in Scarica/Invia (try/finally with `connected` flag); `CncResult.Errors` now printed before every error code.**
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Duration | ~10min |
+| Tasks | 2 completed |
+| Files modified | 1 |
+
+## Acceptance Criteria Results
+
+| Criterion | Status | Notes |
+|-----------|--------|-------|
+| AC-1: Disconnect always runs after connect | Pass | `finally { if (connected) DisconnectAsync() }` in both methods |
+| AC-2: No manual disconnect inside try | Pass | Zero `DisconnectAsync` calls inside try blocks — verified by grep |
+| AC-3: CncResult errors printed on failure | Pass | `PrintErrors(result.Errors)` called at all 8 CncResult failure sites |
+
+## Files Created/Modified
+
+| File | Change | Purpose |
+|------|--------|---------|
+| `Program.cs` | Modified | try/finally pattern, `connected` flag, `PrintErrors` helper added |
+
+## Decisions Made
+
+| Decision | Rationale | Impact |
+|----------|-----------|--------|
+| `bool connected` flag over nested try | Simpler than inner try; clearly marks connect/disconnect boundary | Easy to read, no double-catch complexity |
+| `PrintErrors` before `VediErrore` | Operator sees machine-level detail first, then summary code | Better diagnostics; no behavior change otherwise |
+
+## Deviations from Plan
+
+None — plan executed exactly as written.
+
+## Next Phase Readiness
+
+**Ready:**
+- Phase 11 complete — `Program.cs` clean, `ArgParser` isolated, errors surfaced
+- Phase 12 (docs-cli) can proceed: README needs full CLI param table
+
+**Concerns:** None.
+
+**Blockers:** None.
+
+---
+*Phase: 11-refactor, Plan: 02*
+*Completed: 2026-05-18*

AesCrypt.cs

@@ -1,93 +0,0 @@
-using System;
-using System.IO;
-using System.Security.Cryptography;
-
-namespace NcProgramManager
-{
-        class AesCrypt
-        {
-
-            public static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
-            {
-                // Check arguments.
-                if (plainText == null || plainText.Length <= 0)
-                    throw new ArgumentNullException("plainText");
-                if (Key == null || Key.Length <= 0)
-                    throw new ArgumentNullException("Key");
-                if (IV == null || IV.Length <= 0)
-                    throw new ArgumentNullException("IV");
-                byte[] encrypted;
-
-                // Create an Aes object
-                // with the specified key and IV.
-                using (Aes aesAlg = Aes.Create())
-                {
-                    aesAlg.Key = Key;
-                    aesAlg.IV = IV;
-
-                    // Create an encryptor to perform the stream transform.
-                    ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
-
-                    // Create the streams used for encryption.
-                    using (MemoryStream msEncrypt = new MemoryStream())
-                    {
-                        using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
-                        {
-                            using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
-                            {
-                                //Write all data to the stream.
-                                swEncrypt.Write(plainText);
-                            }
-                            encrypted = msEncrypt.ToArray();
-                        }
-                    }
-                }
-
-                // Return the encrypted bytes from the memory stream.
-                return encrypted;
-            }
-
-            public static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
-            {
-                // Check arguments.
-                if (cipherText == null || cipherText.Length <= 0)
-                    throw new ArgumentNullException("cipherText");
-                if (Key == null || Key.Length <= 0)
-                    throw new ArgumentNullException("Key");
-                if (IV == null || IV.Length <= 0)
-                    throw new ArgumentNullException("IV");
-
-                // Declare the string used to hold
-                // the decrypted text.
-                string plaintext = null;
-
-                // Create an Aes object
-                // with the specified key and IV.
-                using (Aes aesAlg = Aes.Create())
-                {
-                    aesAlg.Key = Key;
-                    aesAlg.IV = IV;
-
-                    // Create a decryptor to perform the stream transform.
-                    ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
-
-                    // Create the streams used for decryption.
-                    using (MemoryStream msDecrypt = new MemoryStream(cipherText))
-                    {
-                        using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
-                        {
-                            using (StreamReader srDecrypt = new StreamReader(csDecrypt))
-                            {
-
-                                // Read the decrypted bytes from the decrypting stream
-                                // and place them in a string.
-                                plaintext = srDecrypt.ReadToEnd();
-                            }
-                        }
-                    }
-                }
-
-                return plaintext;
-            }
-        }
-    }

ArgParser.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using NcProgramManager.Cnc.Models;
+
+namespace NcProgramManager
+{
+    internal static class ArgParser
+    {
+        public static InputArgs Parse(string[] args)
+        {
+            var inputArgs = new InputArgs();
+            var arguments = new List<string>(args);
+
+            var help = arguments.Find(it => new Regex("-help.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(help))
+            {
+                inputArgs.mostraHelp = true;
+                return inputArgs;
+            }
+
+            var azione = arguments.Find(it => new Regex("-azione=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            inputArgs.azione = azione.Substring(8);
+
+            var manufacturer = arguments.Find(it => new Regex("-manufacturer=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(manufacturer))
+            {
+                string mfgVal = manufacturer.Substring(14).Trim().ToLowerInvariant();
+                switch (mfgVal)
+                {
+                    case "heidenhain":  inputArgs.manufacturer = CncManufacturer.Heidenhain;  break;
+                    case "siemens":     inputArgs.manufacturer = CncManufacturer.Siemens;     break;
+                    case "mitsubishi":  inputArgs.manufacturer = CncManufacturer.Mitsubishi;  break;
+                    default:            inputArgs.manufacturer = CncManufacturer.Fanuc;       break;
+                }
+            }
+
+            string tipo = arguments.Find(it => new Regex("-tipo=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            inputArgs.tipo = !string.IsNullOrEmpty(tipo) ? Int32.Parse(tipo.Substring(6)) : 3;
+
+            var ip = arguments.Find(it => new Regex("-ip=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(ip))
+                inputArgs.ip = ip.Substring(4);
+
+            var porta = arguments.Find(it => new Regex("-porta=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(porta))
+                inputArgs.porta = porta.Substring(7);
+
+            var nodo = arguments.Find(it => new Regex("-nodo=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            inputArgs.nodoHssb = !string.IsNullOrEmpty(nodo) ? Int32.Parse(nodo.Substring(6)) : -1;
+
+            var username = arguments.Find(it => new Regex("-username=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(username))
+                inputArgs.username = username.Substring(10);
+
+            var password = arguments.Find(it => new Regex("-password=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(password))
+                inputArgs.password = password.Substring(10);
+
+            var compatibility = arguments.Find(it => new Regex("-compatibility.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(compatibility))
+                inputArgs.compatibilityMode = true;
+
+            var commento = arguments.Find(it => new Regex("-commento=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(commento))
+                inputArgs.commentoProgramma = commento.Substring(10);
+
+            var path = arguments.Find(it => new Regex("-path=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(path))
+                inputArgs.pathCNC = Int16.Parse(path.Substring(6));
+
+            var pathprogramma = arguments.Find(it => new Regex("-pathprogramma=.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(pathprogramma))
+                inputArgs.pathLocaleProgramma = pathprogramma.Substring(15);
+
+            var hasToolOffsetData = arguments.Find(it => new Regex("-tooloffset.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(hasToolOffsetData))
+                inputArgs.hasToolOffsetData = true;
+
+            var hasWorkZeroOffsetData = arguments.Find(it => new Regex("-workzero.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(hasWorkZeroOffsetData))
+                inputArgs.hasWorkZeroOffsetData = true;
+
+            var debugMode = arguments.Find(it => new Regex("-debug.*", RegexOptions.IgnoreCase).IsMatch(it));
+            if (!string.IsNullOrEmpty(debugMode))
+                inputArgs.debugMode = true;
+
+            return inputArgs;
+        }
+    }
+}

Licensing/LicenseValidator.cs

@@ -6,13 +6,8 @@ namespace NcProgramManager.Licensing
 {
     internal class LicenseValidator : ILicenseValidator
     {
-        // Placeholder — replace with real vendor public key XML after Phase 09 generates the key pair.
+        // Real vendor public key -- generated 2026-05-17 with LicenseGenerator keygen.
-        // Generate key pair with the LicenseGenerator tool, then copy the public XML here.
+        private const string PublicKeyXml = "<RSAKeyValue><Modulus>jym+FWWeMb4g2ijaPlMn427s36sdv0FkDp5mKX+wMYGgRSIwUoDnG6nVCj6Z9k25uDf7714BXbg0IaJ/C8KE5TMgqgqsWA9hT79CdJR1eADM5jwMCo43mIIMuDplzdlmgfaW/JwE7QsxzdpfpW1uxU5DVJzsV/RZaRabTK2nSsvzHclMvB+jIQ9VobwTAyYhrvF7nYLtSdGl4YvvZ1O2fzJudvrlCrl5nnRqfPZC+0YnEwcLW0BzWxMiH0UGR/Gz4h7L05OkEwiXYtO+vkslkxIA6jraU0qjoFfDCaZ6HajWZ8lphCpw00Nwa8nEvaiuCRqN/lVOm/9kHXFuAXtA/Q==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
-        private const string PublicKeyXml =
-            "<RSAKeyValue>" +
-            "<Modulus>PLACEHOLDER</Modulus>" +
-            "<Exponent>AQAB</Exponent>" +
-            "</RSAKeyValue>";
 
         private readonly string _publicKeyXml;
 

NcProgramManager.csproj

@@ -72,7 +72,7 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AesCrypt.cs" />
+    <Compile Include="ArgParser.cs" />
     <Compile Include="FanucProgram.cs" />
     <Compile Include="InputArgs.cs" />
     <Compile Include="fwlib32.cs" />

Program.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text.RegularExpressions;
 using NcProgramManager.Cnc;
 using NcProgramManager.Cnc.Models;
 using NcProgramManager.Licensing;
@@ -10,46 +9,44 @@ namespace NcProgramManager
 {
     internal class Program
     {
-        private static InputArgs inputArgs = new InputArgs();
-
         public static int Main(string[] args)
         {
+            InputArgs inputArgs;
             try
             {
-                parseArgomenti(args);
+                inputArgs = ArgParser.Parse(args);
             }
             catch (Exception e)
             {
                 Console.Write("Gestore Programmi FANUC: ");
                 Console.WriteLine(e.Message);
                 Console.WriteLine("Errore parametri input. Consulta `-help' per maggiori informazioni.");
-                vediErrore(-101);
+                VediErrore(-101, false);
                 return -101;
             }
 
             if (inputArgs.mostraHelp)
             {
                 MostraAiuto();
-                vediErrore(0);
+                VediErrore(0, inputArgs.debugMode);
                 return 0;
             }
 
-            string _licFingerprint = new MachineFingerprint().GetFingerprint();
+            string licFingerprint = new MachineFingerprint().GetFingerprint();
-            string _licBase64;
+            string licBase64;
-            string _licPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "license.lic");
+            string licPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "license.lic");
-            if (!LicenseFile.TryRead(_licPath, out _licBase64)
+            if (!LicenseFile.TryRead(licPath, out licBase64)
-                || !new LicenseValidator().Validate(_licFingerprint, _licBase64))
+                || !new LicenseValidator().Validate(licFingerprint, licBase64))
             {
                 Console.WriteLine("Licenza ERRATA");
-                vediErrore(-100);
+                VediErrore(-100, inputArgs.debugMode);
                 return -1;
             }
 
-            // Validate required params
             bool needsIp = inputArgs.manufacturer != CncManufacturer.Fanuc || inputArgs.nodoHssb == -1;
             if (inputArgs.azione == "" || (needsIp && string.IsNullOrEmpty(inputArgs.ip)) || inputArgs.pathLocaleProgramma == "")
             {
-                vediErrore(-102);
+                VediErrore(-102, inputArgs.debugMode);
                 return -102;
             }
 
@@ -70,10 +67,10 @@ namespace NcProgramManager
 
                 switch (inputArgs.azione.ToUpperInvariant())
                 {
-                    case "SCARICA": return Scarica(machine);
+                    case "SCARICA": return Scarica(machine, inputArgs);
-                    case "INVIA":   return Invia(machine);
+                    case "INVIA":   return Invia(machine, inputArgs);
                     default:
-                        vediErrore(-103);
+                        VediErrore(-103, inputArgs.debugMode);
                         return -103;
                 }
             }
@@ -84,31 +81,33 @@ namespace NcProgramManager
             }
         }
 
-        static int Scarica(ICncMachine macchina)
+        static int Scarica(ICncMachine macchina, InputArgs inputArgs)
         {
             Console.WriteLine("RICEVI DA CNC-->");
+            bool connected = false;
             try
             {
                 var connResult = macchina.ConnectAsync().GetAwaiter().GetResult();
                 if (!connResult.Success)
                 {
                     Console.WriteLine("Macchina non connessa");
-                    vediErrore(-201);
+                    PrintErrors(connResult.Errors);
+                    VediErrore(-201, inputArgs.debugMode);
                     return -201;
                 }
+                connected = true;
 
                 Console.WriteLine("Inizio RICEZIONE NCProgram");
                 var progResult = macchina.ReadProgramAsync(inputArgs.pathCNC.ToString()).GetAwaiter().GetResult();
                 Console.WriteLine("Fine RICEZIONE NCProgram");
                 if (!progResult.Success || string.IsNullOrEmpty(progResult.Value))
                 {
-                    macchina.DisconnectAsync().GetAwaiter().GetResult();
+                    PrintErrors(progResult.Errors);
-                    vediErrore(-204);
+                    VediErrore(-204, inputArgs.debugMode);
                     return -204;
                 }
 
                 FanucProgram programma = new FanucProgram(progResult.Value);
-
                 IFanucMachine fanuc = macchina as IFanucMachine;
 
                 if (inputArgs.hasToolOffsetData)
@@ -116,8 +115,7 @@ namespace NcProgramManager
                     if (fanuc == null)
                     {
                         Console.WriteLine("ToolOffset non supportato per questo produttore");
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        VediErrore(-205, inputArgs.debugMode);
-                        vediErrore(-205);
                         return -205;
                     }
                     Console.WriteLine("Inizio RICEZIONE ToolOffsetData");
@@ -125,8 +123,8 @@ namespace NcProgramManager
                     Console.WriteLine("Fine RICEZIONE ToolOffsetData");
                     if (!toolResult.Success || string.IsNullOrEmpty(toolResult.Value))
                     {
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        PrintErrors(toolResult.Errors);
-                        vediErrore(-205);
+                        VediErrore(-205, inputArgs.debugMode);
                         return -205;
                     }
                     programma.setValue(toolResult.Value, FanucProgram.FILE_TYPE.TOOL_OFFEST_DATA);
@@ -137,8 +135,7 @@ namespace NcProgramManager
                     if (fanuc == null)
                     {
                         Console.WriteLine("WorkZeroOffset non supportato per questo produttore");
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        VediErrore(-206, inputArgs.debugMode);
-                        vediErrore(-206);
                         return -206;
                     }
                     Console.WriteLine("Inizio RICEZIONE WorkZeroOffsetData");
@@ -146,38 +143,45 @@ namespace NcProgramManager
                     Console.WriteLine("Fine RICEZIONE WorkZeroOffsetData");
                     if (!workResult.Success || string.IsNullOrEmpty(workResult.Value))
                     {
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        PrintErrors(workResult.Errors);
-                        vediErrore(-206);
+                        VediErrore(-206, inputArgs.debugMode);
                         return -206;
                     }
                     programma.setValue(workResult.Value, FanucProgram.FILE_TYPE.WORK_ZERO_OFFSET);
                 }
 
-                macchina.DisconnectAsync().GetAwaiter().GetResult();
                 File.WriteAllText(inputArgs.pathLocaleProgramma, programma.ToString());
-                vediErrore(0);
+                VediErrore(0, inputArgs.debugMode);
                 return 0;
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
-                vediErrore(-202);
+                VediErrore(-202, inputArgs.debugMode);
                 return -202;
             }
+            finally
+            {
+                if (connected)
+                    macchina.DisconnectAsync().GetAwaiter().GetResult();
+            }
         }
 
-        static int Invia(ICncMachine macchina)
+        static int Invia(ICncMachine macchina, InputArgs inputArgs)
         {
             Console.WriteLine("INVIA A CNC-->");
+            bool connected = false;
             try
             {
                 var connResult = macchina.ConnectAsync().GetAwaiter().GetResult();
                 if (!connResult.Success)
                 {
                     Console.WriteLine("Macchina non connessa");
-                    vediErrore(-201);
+                    PrintErrors(connResult.Errors);
+                    VediErrore(-201, inputArgs.debugMode);
                     return -201;
                 }
+                connected = true;
 
                 FanucProgram programma = new FanucProgram(File.ReadAllText(inputArgs.pathLocaleProgramma));
                 if (!string.IsNullOrEmpty(inputArgs.commentoProgramma))
@@ -197,8 +201,8 @@ namespace NcProgramManager
                     Console.WriteLine("Fine INVIO NCProgram");
                     if (!writeResult.Success)
                     {
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        PrintErrors(writeResult.Errors);
-                        vediErrore(-204);
+                        VediErrore(-204, inputArgs.debugMode);
                         return -204;
                     }
                 }
@@ -210,8 +214,7 @@ namespace NcProgramManager
                     if (fanuc == null)
                     {
                         Console.WriteLine("ToolOffset non supportato per questo produttore");
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        VediErrore(-205, inputArgs.debugMode);
-                        vediErrore(-205);
                         return -205;
                     }
                     Console.WriteLine("Inizio INVIO ToolOffsetData");
@@ -219,8 +222,8 @@ namespace NcProgramManager
                     Console.WriteLine("Fine INVIO ToolOffsetData");
                     if (!toolResult.Success)
                     {
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        PrintErrors(toolResult.Errors);
-                        vediErrore(-205);
+                        VediErrore(-205, inputArgs.debugMode);
                         return -205;
                     }
                 }
@@ -230,8 +233,7 @@ namespace NcProgramManager
                     if (fanuc == null)
                     {
                         Console.WriteLine("WorkZeroOffset non supportato per questo produttore");
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        VediErrore(-206, inputArgs.debugMode);
-                        vediErrore(-206);
                         return -206;
                     }
                     Console.WriteLine("Inizio INVIO WorkZeroOffsetData");
@@ -239,25 +241,36 @@ namespace NcProgramManager
                     Console.WriteLine("Fine INVIO WorkZeroOffsetData");
                     if (!workResult.Success)
                     {
-                        macchina.DisconnectAsync().GetAwaiter().GetResult();
+                        PrintErrors(workResult.Errors);
-                        vediErrore(-206);
+                        VediErrore(-206, inputArgs.debugMode);
                         return -206;
                     }
                 }
 
-                macchina.DisconnectAsync().GetAwaiter().GetResult();
+                VediErrore(0, inputArgs.debugMode);
-                vediErrore(0);
                 return 0;
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
-                vediErrore(-202);
+                VediErrore(-202, inputArgs.debugMode);
                 return -202;
             }
+            finally
+            {
+                if (connected)
+                    macchina.DisconnectAsync().GetAwaiter().GetResult();
+            }
         }
 
-        static void vediErrore(int errore)
+        static void PrintErrors(IReadOnlyList<CncError> errors)
+        {
+            if (errors == null) return;
+            foreach (var e in errors)
+                Console.WriteLine("  " + e.ToString());
+        }
+
+        static void VediErrore(int errore, bool debugMode)
         {
             Console.WriteLine("Errore:" + errore);
             Console.WriteLine();
@@ -274,7 +287,7 @@ namespace NcProgramManager
             Console.WriteLine("-206 : Errore in fase invio/ricezione work zero offest data");
             Console.WriteLine("-207 : Posizionare il CN in MDI o EDIT per eseguire l'invio di un programma");
             Console.WriteLine("-208 : Programma CN Caricato ma non settato a main.");
-            if (inputArgs.debugMode)
+            if (debugMode)
                 Console.ReadLine();
         }
 
@@ -336,71 +349,5 @@ namespace NcProgramManager
             Console.WriteLine("-207 : Posizionare il CN in MDI o EDIT per eseguire l'invio di un programma");
             Console.WriteLine("-208 : Programma CN Caricato ma non settato a main.");
         }
-
-        private static void parseArgomenti(string[] args)
-        {
-            List<string> arguments = new List<string>(args);
-            var help = arguments.Find(it => new Regex("-help.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(help))
-            {
-                inputArgs.mostraHelp = true;
-                return;
-            }
-            var azione = arguments.Find(it => new Regex("-azione=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            inputArgs.azione = azione.Substring(8);
-            var manufacturer = arguments.Find(it => new Regex("-manufacturer=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(manufacturer))
-            {
-                string mfgVal = manufacturer.Substring(14).Trim().ToLowerInvariant();
-                switch (mfgVal)
-                {
-                    case "heidenhain":  inputArgs.manufacturer = CncManufacturer.Heidenhain;  break;
-                    case "siemens":     inputArgs.manufacturer = CncManufacturer.Siemens;     break;
-                    case "mitsubishi":  inputArgs.manufacturer = CncManufacturer.Mitsubishi;  break;
-                    default:            inputArgs.manufacturer = CncManufacturer.Fanuc;       break;
-                }
-            }
-            string tipo = arguments.Find(it => new Regex("-tipo=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(tipo))
-                inputArgs.tipo = Int32.Parse(tipo.Substring(6));
-            else inputArgs.tipo = 3;
-            var ip = arguments.Find(it => new Regex("-ip=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(ip))
-                inputArgs.ip = ip.Substring(4);
-            var porta = arguments.Find(it => new Regex("-porta=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(porta))
-                inputArgs.porta = porta.Substring(7);
-            var nodo = arguments.Find(it => new Regex("-nodo=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(nodo))
-                inputArgs.nodoHssb = Int32.Parse(nodo.Substring(6));
-            else inputArgs.nodoHssb = -1;
-            var username = arguments.Find(it => new Regex("-username=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(username))
-                inputArgs.username = username.Substring(10);
-            var password = arguments.Find(it => new Regex("-password=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(password))
-                inputArgs.password = password.Substring(10);
-            var compatibility = arguments.Find(it => new Regex("-compatibility.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(compatibility))
-                inputArgs.compatibilityMode = true;
-            var commento = arguments.Find(it => new Regex("-commento=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(commento))
-                inputArgs.commentoProgramma = commento.Substring(10);
-            var path = arguments.Find(it => new Regex("-path=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(path))
-                inputArgs.pathCNC = Int16.Parse(path.Substring(6));
-            var pathprogramma = arguments.Find(it => new Regex("-pathprogramma=.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(pathprogramma))
-                inputArgs.pathLocaleProgramma = pathprogramma.Substring(15);
-            var hasToolOffestData = arguments.Find(it => new Regex("-tooloffset.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(hasToolOffestData))
-                inputArgs.hasToolOffsetData = true;
-            var hasWorkZeroOffsetData = arguments.Find(it => new Regex("-workzero.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(hasWorkZeroOffsetData))
-                inputArgs.hasWorkZeroOffsetData = true;
-            var debugMode = arguments.Find(it => new Regex("-debug.*", RegexOptions.IgnoreCase).IsMatch(it));
-            if (!string.IsNullOrEmpty(debugMode))
-                inputArgs.debugMode = true;
-        }
     }
 }

README.md

@@ -0,0 +1,67 @@
+# NcProgramManager
+
+Software per il trasferimento di programmi CNC da e verso controller di macchine utensili. Supporta Fanuc (FOCAS), Heidenhain (LSV2), Siemens Sinumerik (FTP) e Mitsubishi (FTP). Funziona completamente offline come applicazione console per Windows.
+
+## Requisiti
+
+- Windows (qualsiasi versione compatibile con .NET Framework 4.7.2)
+- .NET Framework 4.7.2 installato
+- File `license.lic` valido (rilasciato dal fornitore)
+
+## Licenza
+
+Copiare il file `license.lic` nella stessa cartella dell'eseguibile `NcProgramManager.exe`. Senza licenza valida il programma si chiude all'avvio.
+
+Per ottenere una licenza contattare il fornitore fornendo l'impronta hardware della macchina. L'impronta si ottiene eseguendo il comando `fingerprint` dello strumento `LicenseGenerator.exe` sulla macchina di destinazione.
+
+## Utilizzo
+
+```
+NcProgramManager.exe -manufacturer=<tipo> -azione=<azione> -ip=<ip> -porta=<porta> [opzioni]
+```
+
+### Parametri
+
+| Parametro | Valori | Descrizione |
+|-----------|--------|-------------|
+| `-manufacturer=` | `fanuc` / `heidenhain` / `siemens` / `mitsubishi` | Tipo di controller CNC (predefinito: `fanuc`) |
+| `-azione=` | `Scarica` / `Invia` / ... | Azione da eseguire |
+| `-ip=` | indirizzo IP | Indirizzo IP del controller CNC |
+| `-porta=` | numero porta | Porta di connessione |
+| `-username=` | nome utente | Solo per Heidenhain, Siemens, Mitsubishi |
+| `-password=` | password | Solo per Heidenhain, Siemens, Mitsubishi |
+
+La licenza viene letta automaticamente dal file `license.lic` nella cartella dell'eseguibile — nessun parametro aggiuntivo richiesto.
+
+## Esempi
+
+Scarica programma da controller Fanuc:
+
+```
+NcProgramManager.exe -manufacturer=fanuc -azione=Scarica -ip=192.168.1.100 -porta=8193
+```
+
+Invia programma a controller Heidenhain:
+
+```
+NcProgramManager.exe -manufacturer=heidenhain -azione=Invia -ip=192.168.1.50 -porta=19000 -username=operator -password=secret
+```
+
+Scarica programma da Siemens Sinumerik:
+
+```
+NcProgramManager.exe -manufacturer=siemens -azione=Scarica -ip=192.168.1.200 -porta=21 -username=admin -password=secret
+```
+
+## Controller supportati
+
+| Produttore | Protocollo | Porta predefinita | Note |
+|------------|------------|-------------------|------|
+| Fanuc | FOCAS (DLL 32-bit) | 8193 | Richiede `fwlib32.dll` nella stessa cartella |
+| Heidenhain | LSV2 (TCP) | 19000 | Testato su TNC series |
+| Siemens | FTP | 21 | Directory programmi: `/_N_MPF_DIR/` — richiede opzione FTP abilitata sul Sinumerik |
+| Mitsubishi | FTP | 21 | Directory programmi: `/PRG/` |
+
+## Validazione del programma NC
+
+Prima di inviare un programma al controller, NcProgramManager esegue una validazione automatica del codice NC. Gli errori bloccano il trasferimento. Gli avvisi vengono registrati ma non interrompono l'operazione.