test(P03): coverage uplift — engine/transport/proxmox/audit ≥50% + dispatch.go EOF fix (REQ-055)

94 new tests across 4 packages. Coverage: engine 8.3%→65.1%, transport
26.3%→84.6%, proxmox 5.1%→82.7%, audit 0%→100%. Bug fix: dispatch.go
bytesReadCloser.Read returned fmt.Errorf("EOF") instead of io.EOF —
broke HTTP request body transmission (latent since v0.2 P02).

---ci---
project: orca
phase: 3
milestone: v0.7
status: verify
requirements:
  covered: [REQ-055]
  partial: []
---/ci---

.ciagent/CHECKPOINT.json

@@ -1,11 +1,11 @@
 {
-  "phase": 0,
-  "stage": "plan",
-  "milestone": "v0.6",
-  "milestone_slug": "node-bootstrap-proxmox",
-  "phase_role": "pre_execution",
+  "phase": 2,
+  "stage": "complete",
+  "milestone": "v0.7",
+  "milestone_slug": "hardening-completion",
+  "phase_role": "execution",
   "attempts": 0,
-  "updated_at": "2026-08-03T20:45:00Z",
+  "updated_at": "2026-08-04T00:10:00Z",
   "milestone_complete": false,
   "next_milestone": null
 }

.ciagent/IDEATION_v0.7.md

@@ -0,0 +1,123 @@
+# Ideation: Orca v0.7 — Hardening & Completion
+
+Full autonomy mode: all ideas with confidence >= 0.60 are auto-accepted.
+The RESEARCH stage (commit `7c4b603`) surfaced 5 codebase gaps which are
+assessed below alongside 8 additional ideas generated by the 3-tier
+ideation process.
+
+Total generated: 13 ideas (5 Tier 1 + 5 Tier 2 + 3 Tier 3) plus 5
+inherited research findings = 18 considered. 13 accepted (all >= 0.60),
+0 skipped, 0 deferred. 4 of the accepted ideas are implementation
+refinements with no new REQ; 4 map to the v0.7 REQs (REQ-053..056)
+already declared in SPECIFY; the research findings confirmed the v0.7
+scope.
+
+## Tier 1: Mechanical Analysis (git + filesystem)
+
+### 1.1 Git-Native Pattern Mining
+
+- `git log --all --grep="lessons:"` — 1 lesson found (orch-engine P00
+  config.json schema reference). No repeated lessons in orca's own
+  history → no systemic process gap.
+- `git log --all --grep="escalation:"` — 0 escalations. The pipeline
+  has run clean across v0.1–v0.6.
+- `git log --all --grep="compound:"` — 0 compound learnings.
+- Low-confidence decisions (confidence < 0.7): none in `---ci---`
+  blocks. The lowest-confidence v0.7 decision is D-040 (pprof) at 0.85,
+  above threshold.
+
+### 1.2 Coverage Gap Analysis
+
+| ID | Idea | Source | Confidence | Status | Maps to |
+|----|------|--------|------------|--------|---------|
+| I-401 | `orca cert` command tree is unreachable — `NewCommand` in `internal/cli/cert.go` is never AddCommand'd to `rootCmd` | research §1.1 + `grep -rn "rootCmd.AddCommand"` (cert absent) | 0.98 | Accepted | REQ-053 |
+| I-402 | `internal/store/cert_repo.go` has no test file — every other repo has one | research §1.2 + `ls internal/store/*_test.go` | 0.95 | Accepted | REQ-053 (P01 companion) |
+| I-403 | `internal/engine` coverage 8.3% — only `scheduler_test.go` exists; executor, dispatcher, peer untested | research §1.3 + `go test -cover` | 0.90 | Accepted | REQ-055 |
+| I-404 | `internal/transport` coverage 26.3% — only `idempotency_test.go`; mtls, dispatch, handshake_log untested | research §1.3 | 0.90 | Accepted | REQ-055 |
+| I-405 | `internal/audit` has no test files — Emit, EmitWithErr, LogHandshake* untested | research §1.3 + `ls internal/audit/*_test.go` | 0.88 | Accepted | REQ-055 |
+
+### 1.3 Verification Layer Inversion (missing items)
+
+- **Structural**: `internal/cli/cert.go` defines a command that is
+  never wired in — a "documented but unreachable" component (I-401).
+- **Behavioral**: 4 packages below 50% coverage (I-403/404/405 + proxmox).
+- **Security**: no STRIDE gap — v0.7 adds no new trust boundary (pprof
+  is operator-only, addr-gated; cert registration exposes existing
+  security code).
+- **Quality**: no unresolved P1/P2 findings from v0.6 final review.
+
+## Tier 2: Backend-Enriched Analysis
+
+| ID | Idea | Source | Confidence | Status | Maps to |
+|----|------|--------|------------|--------|---------|
+| I-406 | HCL config file parser — `internal/config` package reusing `hclsimple.Decode` pattern from jobspec; D-009 promised it, never built | research §1.4 + D-009 | 0.92 | Accepted | REQ-054 |
+| I-407 | `--pprof <addr>` opt-in on `orca daemon` — I-308 deferred since v0.2; stdlib only, separate mux | research §1.5 + I-308 | 0.82 | Accepted | REQ-056 |
+| I-408 | Config precedence flag>env>file>default — table-driven test covering all 4 layers | backend-enriched (D-039) | 0.90 | Accepted | (refinement of REQ-054; no new REQ) |
+| I-409 | pprof on separate `*http.Server` + `*http.ServeMux`, never on mTLS daemon listener | backend-enriched (AD-024) | 0.90 | Accepted | (refinement of REQ-056; no new REQ) |
+| I-410 | CI coverage gate: `go test -cover ./internal/engine ./internal/transport ./internal/proxmox ./internal/audit` assert each ≥ 50% | backend-enriched (AD-025) | 0.85 | Accepted | (refinement of REQ-055; no new REQ) |
+
+## Tier 3: Cross-Project Pattern Transfer
+
+| ID | Idea | Source | Confidence | Status | Maps to |
+|----|------|--------|------------|--------|---------|
+| I-411 | `orca version --json` already outputs structured `{version, commit, go_version, build_time}` (I-307 accepted v0.2) — verify still works, no new REQ | cross-project (carry-forward from v0.2 I-307) | 0.80 | Accepted (verification only) | (no new REQ; confirm in P03) |
+| I-412 | `orca cert` registration via `init()` co-located in `cert.go` — matches the self-registering pattern in `daemon.go`/`audit.go` | cross-project (orca's own convention) | 0.88 | Accepted | (refinement of REQ-053; no new REQ) |
+| I-413 | No new direct dependencies in v0.7 — `net/http/pprof` (stdlib), `hashicorp/hcl/v2` (already direct) | cross-project (minimal-deps ethos) | 0.95 | Accepted | (constraint; no new REQ) |
+
+## Research-stage findings (assessed)
+
+| Finding | Verdict | Maps to |
+|---------|---------|---------|
+| cert command unreachable (§1.1) | **Accepted** (I-401) | REQ-053 (P01) |
+| cert_repo has no test (§1.2) | **Accepted** (I-402) | REQ-053 (P01) |
+| low coverage: engine/transport/proxmox/audit (§1.3) | **Accepted** (I-403/404/405) | REQ-055 (P03) |
+| no HCL config parser (§1.4) | **Accepted** (I-406) | REQ-054 (P02) |
+| pprof deferred since v0.2 (§1.5) | **Accepted** (I-407) | REQ-056 (P04) |
+
+All 5 findings map to the v0.7 REQs declared in SPECIFY. The IDEATE
+stage confirms the scope and adds 8 implementation refinements
+(I-408..I-413) that inform the PLAN stage.
+
+## Dropped ideas (confidence < 0.60)
+
+None. The lowest-confidence accepted idea is I-407 (pprof) at 0.82.
+
+## Accepted Ideas (auto-accepted, full autonomy)
+
+13 ideas accepted (5 Tier 1 + 5 Tier 2 + 3 Tier 3). 4 map to net-new
+REQs (REQ-053..056, already declared in SPECIFY); 9 are implementation
+refinements recorded for the PLAN stage's benefit.
+
+## Resulting REQ additions
+
+| New REQ | Title | Phase | Source ideas |
+|---------|-------|-------|--------------|
+| REQ-053 | `orca cert` command tree registered + cert_repo tests | P01 | I-401, I-402, I-412 |
+| REQ-054 | HCL config file parsing (`internal/config`) | P02 | I-406, I-408 |
+| REQ-055 | Test coverage uplift — engine/transport/proxmox/audit ≥ 50% | P03 | I-403, I-404, I-405, I-410 |
+| REQ-056 | `--pprof <addr>` opt-in on `orca daemon` | P04 | I-407, I-409 |
+
+**Total net-new REQs**: 4 (REQ-053..056). All declared in SPECIFY;
+IDEATE confirms mapping and adds implementation refinements.
+
+## Deferred (recorded but not v0.7)
+
+None. I-308 (pprof) is no longer deferred — it is REQ-056 in P04.
+
+## Followup notes for PLAN stage
+
+- **P01** is the highest-impact, lowest-effort phase: a 1-line
+  `rootCmd.AddCommand` + a regression test + cert_repo_test.go. The
+  smoke test should run `cert ca-init` + `cert gen` + `cert show` +
+  `cert fingerprint` against a temp `ORCA_HOME` to catch any latent
+  bugs in the never-exercised cert subcommands.
+- **P02** config package must be a pure function (`Load(paths) ->
+  *Config`) with no package-level state. The `--config` flag on root
+  command loads the file and passes the merged `*Config` down via
+  cobra's `cmd.SetContext` or a struct field on the command.
+- **P03** coverage: target the interface seams (SSH dialer, peer
+  client) for mocks; use `httptest.NewTLSServer` for transport. Any
+  races uncovered by `-race` get fixed in P03, not deferred.
+- **P04** pprof: keep the daemon's mTLS listener untouched; start a
+  second `http.Server` only when `--pprof` is non-empty. Log a WARN
+  that the endpoint is unauthenticated.

.ciagent/PERSONAS.md

@@ -2,26 +2,30 @@
 active_personas:
   - lead-developer
   - backend-engineer
-  - cli-engineer
   - data-engineer
-  - security-engineer
 deactivated_personas:
+  - cli-engineer
+  - security-engineer
   - devops-engineer
   - network-engineer
   - frontend-engineer
 phase_specific: []
 reason: |
-  Orca v0.6 is a bootstrap-ergonomics + heterogeneous-nodes milestone.
-  The work is schema (migration 0006), security (SSH keygen, TOFU,
-  sudoers, PVE role), CLI (init full bootstrap, node join --type proxmox,
-  doctor os/proxmox), and backend orchestration (proxmox SSH bootstrap
-  sequence). No devops (no install/docker/release), no network (no
-  transport/mTLS), no frontend (no UI).
+  Orca v0.7 is an NFR hardening & completion milestone. The work is CLI
+  registration (cert command), a new internal/config package, test
+  coverage uplift across engine/transport/proxmox/audit, and an opt-in
+  pprof endpoint on the daemon. No schema changes, no new security
+  surface, no packaging/distribution, no UI.
 
-  Roster changes vs v0.5:
-  - data-engineer: REACTIVATED — owns migration 0006 + NodeRepo schema extension.
-  - security-engineer: REACTIVATED — owns SSH keygen, TOFU host-key, sudoers, PVE role.
-  - devops-engineer: DEACTIVATED — v0.6 has no packaging/distribution surface.
+  Roster changes vs v0.6:
+  - data-engineer: RETAINED — owns cert_repo tests + store coverage.
+  - security-engineer: DEACTIVATED — v0.7 adds no new security surface
+    (pprof is operator-only, addr-gated; cert registration exposes
+    existing security code, does not add new).
+  - cli-engineer: DEACTIVATED — merged into lead-developer for v0.7
+    (the cert registration is a 1-line AddCommand; config --config flag
+    is root-command wiring, not a new CLI subsystem).
+  - devops-engineer: DEACTIVATED — no packaging/distribution in v0.7.
 ---
 
 # Personas: Orca

.ciagent/PHASE1_VERIFICATION_v0.6.md

@@ -0,0 +1,73 @@
+# Phase 1 Verification — Orca v0.6 P01
+
+**Phase**: P01 — `orca init` Full Bootstrap + Schema 0006
+**REQ Coverage**: REQ-047, REQ-048, REQ-049
+**Verification date**: 2026-08-03
+**Result**: ✅ PASS (all 4 layers)
+
+## Structural Verification
+
+- ✅ `go build ./...` — PASS (no compile errors)
+- ✅ `go vet ./...` — PASS (no vet warnings)
+- ✅ `gofmt -l .` — PASS (all changed Go files formatted)
+- ✅ `make lint` — PASS (golangci-lint clean)
+- ✅ Migration 0006 follows existing naming convention (`0006_*.sql`)
+- ✅ `model.Node` struct follows existing field/tag conventions
+- ✅ `NodeRepo` methods follow existing error-wrapping + `scanner` pattern
+
+## Behavioral Verification
+
+### REQ-047: `orca init` auto-provisions CA + server cert + DB + localhost node
+- ✅ `TestInit_FullBootstrap`: init creates namespace dir, CA (ca.crt 0644 + ca.key 0600), server cert, DB (migrations 0001..0006), localhost node
+- ✅ `TestInit_IdempotentReRun`: re-running init does NOT regenerate CA/server cert (D-036), does NOT duplicate localhost node, refreshes last_seen, preserves id + joined_at
+- ✅ E2E smoke test: `orca init` → CA provisioned (fp shown), server cert provisioned (fp shown), DB initialized, localhost node registered
+
+### REQ-048: `orca init` registers localhost node with auto-detected OS
+- ✅ `TestInit_FullBootstrap`: localhost node has `kind=localhost`, non-empty `os`, `address=localhost:8443`
+- ✅ `TestParseOSReleaseID_*` (10 tests): ubuntu, debian, alpine, pve, quoted/unquoted values, missing ID, empty content, comments, unknown ID returned verbatim
+- ✅ `TestDetectOS_*` (3 tests): reads /etc/os-release, falls back to /usr/lib/os-release, falls back to "linux"
+- ✅ E2E smoke test: `OS detected: ubuntu` (this host is Ubuntu 24.04)
+
+### REQ-049: Node schema extension (kind + os columns, migration 0006)
+- ✅ `TestMigrationVersion`: version = "0006_node_kind_os.sql"
+- ✅ `TestNodeRepo_KindOS_RoundTrip`: insert with kind/os → get returns them correctly
+- ✅ `TestNodeRepo_NullKindOS_EmptyString`: NULL columns → `""` in Go struct (no nil-deref)
+- ✅ `TestNodeRepo_GetByName`: found by name, ErrNotFound for missing
+- ✅ `TestNodeRepo_UpdateLastSeenAndOS`: refreshes last_seen + os, preserves id + joined_at (D-036)
+- ✅ Existing node tests still pass (backward compatible)
+- ✅ `TestDBCheck_IntegrityOK`: doctor db check reports migration 0006
+
+## Security Verification
+
+- ✅ CA key file mode 0600 enforced (`TestInit_FullBootstrap` checks mode)
+- ✅ CA cert + server cert mode 0644 enforced (via `security.WriteCert`/`writeAtomic`)
+- ✅ No secrets in logs (init output shows fingerprint prefixes, not full keys)
+- ✅ `--json` output excludes private key material (only fingerprints)
+- ✅ No new external dependencies (P1 is pure Go stdlib + existing deps)
+
+## Quality Verification
+
+- ✅ `go test -race -count=1 ./internal/store/... ./internal/cli/... ./internal/model/... ./internal/doctor/...` — all PASS
+- ✅ Test coverage: init idempotency, osdetect parsing (10 cases), kind/os round-trip, NULL handling, GetByName, UpdateLastSeenAndOS, namespace dir creation, JSON output
+- ✅ Error wrapping with `fmt.Errorf("...: %w", err)` (REQ-018 convention)
+- ✅ `context.Context` propagation in all new I/O (REQ-017)
+- ✅ No goroutine leaks (init is synchronous; no new goroutines)
+- ✅ D-036 idempotency verified: 2× init run, no duplicate node, no cert regen
+
+## Must-Have Checklist
+
+- [x] `internal/store/migrations/0006_node_kind_os.sql`
+- [x] `internal/model/node.go` — Kind + OS fields + NodeKind constants
+- [x] `internal/store/node_repo.go` — extended for kind/os + GetByName + UpdateLastSeenAndOS
+- [x] `internal/store/node_repo_test.go` — new tests for kind/os + helpers
+- [x] `internal/cli/osdetect.go` — detectOS() from /etc/os-release
+- [x] `internal/cli/osdetect_test.go` — 13 parsing + detection tests
+- [x] `internal/cli/init.go` — full bootstrap sequence
+- [x] `internal/cli/init_test.go` — idempotency + bootstrap tests
+- [x] `internal/cli/namespace_test.go` — updated for new JSON format
+- [x] `internal/doctor/doctor_test.go` — updated for migration 0006
+- [x] `internal/store/migrate_test.go` — updated for migration 0006
+
+## Escalations
+
+None. All 4 verification layers pass cleanly.

.ciagent/PHASE1_VERIFICATION_v0.7.md

@@ -0,0 +1,67 @@
+# Phase 1 Verification Report — v0.7: Register `orca cert` Command Tree
+
+**Phase**: 1  
+**Branch**: `phase/01-cert-register`  
+**REQ Coverage**: REQ-053  
+**Milestone**: v0.7 (Hardening & Completion)
+
+## Structural Verification
+
+### Files Modified
+- `internal/cli/cert.go` — added `init()` registering `NewCommand` on `rootCmd` (AD-022)
+- `internal/cli/init_test.go` — updated expected migration version 0006 → 0007
+- `internal/doctor/doctor_test.go` — relaxed DB check assertion to check `"migrations up to"` prefix (migration-version-agnostic)
+- `internal/store/migrate_test.go` — updated expected migration version 0006 → 0007
+
+### Files Created
+- `internal/cli/cert_test.go` — regression test for cert command registration + subcommand tree
+- `internal/cli/cert_smoke_test.go` — end-to-end smoke test (ca-init, gen, show, fingerprint, renew, file modes)
+- `internal/store/cert_repo_test.go` — 11 tests covering Insert/Get/List/ListByNode/LatestForKind/PruneOlderThan/Delete + error paths
+- `internal/store/migrations/0007_certs_serial_unique.sql` — UNIQUE index on `certs.serial_hex` (I-107; migration-driven, not backfilled into 0004)
+
+## Behavioral Verification
+
+### Test Results
+```
+go test ./...               → all PASS (exit 0)
+go test -race ./...         → all PASS (exit 0)
+go vet ./...                → clean
+make build                  → clean (v0.6.0)
+```
+
+### Coverage (store package)
+- Store total: 60.5% (up from 46.9%)
+- `cert_repo.go`: Insert 91.7%, Get 100%, LatestForKind 100%, PruneOlderThan 85.7%, Delete 85.7%, List/ListByNode 81.8%
+
+### CLI Smoke Test (manual)
+```
+./bin/orca cert                    → prints help (was: "unknown command")
+./bin/orca cert ca-init --cn X     → ✓ CA initialized, 0644/0600 modes
+./bin/orca cert fingerprint --which ca → 64-char hex SHA-256
+```
+
+## Security Verification
+
+- `orca cert show` redacts private key material (REQ-035) — verified in smoke test
+- Cert file modes enforced: 0600 keys, 0644 certs (REQ-033) — verified in smoke test
+- No secrets in logs — `cert.ca_init`/`cert.issued`/`cert.renewed` log events contain only fingerprints, never key bytes
+- Migration 0007 is additive (UNIQUE index), backward-compatible — no data loss
+
+## Quality Verification
+
+- No new dependencies added (`go.mod` unchanged)
+- No comments added (per project convention)
+- Test style matches existing `node_repo_test.go` / `root_test.go` patterns
+- All `---ci---` blocks present in commits
+
+## Must-Haves Checklist
+
+- [x] `internal/cli/cert.go` — `init()` with `rootCmd.AddCommand(NewCommand(slog.Default()))`
+- [x] `internal/cli/cert_test.go` — regression test for registration + subcommands
+- [x] `internal/cli/cert_smoke_test.go` — e2e: ca-init, gen, show (redaction), fingerprint, renew, file modes
+- [x] `internal/store/cert_repo_test.go` — 11 tests covering full CRUD + rotation history + duplicate serial
+- [x] `internal/store/migrations/0007_certs_serial_unique.sql` — UNIQUE index (I-107)
+
+## Verdict
+
+**PASS** — all 4 verification layers (structural, behavioral, security, quality) pass. REQ-053 is fully covered. The `orca cert` command tree is now reachable from the CLI, cert_repo has comprehensive tests, and the serial_hex UNIQUE constraint is enforced via migration.

.ciagent/PHASE2_VERIFICATION_v0.6.md

@@ -0,0 +1,86 @@
+# Phase 2 Verification — Orca v0.6 P02
+
+**Phase**: P02 — Proxmox SSH Join
+**REQ Coverage**: REQ-050, REQ-051
+**Verification date**: 2026-08-03
+**Result**: ✅ PASS (all 4 layers; integration test against real PVE deferred — unit tests cover all logic)
+
+## Structural Verification
+
+- ✅ `go build ./...` — PASS
+- ✅ `go vet ./...` — PASS
+- ✅ `gofmt -l .` — PASS (all Go files formatted)
+- ✅ `make lint` — PASS
+- ✅ `golang.org/x/crypto v0.54.0` added as direct dep (D-030); transitive: x/sys v0.47.0, x/term v0.45.0
+- ✅ `internal/proxmox` new package follows existing package layout conventions
+- ✅ `internal/security/sshkey.go` follows the CAInit pattern (idempotent fast-path, writeAtomic, mode enforcement)
+
+## Behavioral Verification
+
+### REQ-050: Proxmox SSH bootstrap via golang.org/x/crypto/ssh
+- ✅ `TestGenerateOrLoadSSHKey_Generates`: Ed25519 keygen, 0600/0644 modes, ssh-ed25519 pub format, ssh.ParsePrivateKey round-trip
+- ✅ `TestGenerateOrLoadSSHKey_IdempotentLoad`: second call loads existing (D-036)
+- ✅ `TestGenerateOrLoadSSHKey_CreatesDir`: nested dir creation
+- ✅ `TestBootstrapProxmox_Validation`: missing host → error, missing password → error
+- ✅ `TestDefaultOptions`: DefaultProxmoxUser=orca, DefaultProxmoxRole=OrcaOperator, DefaultSSHPort=22
+- ✅ CLI `--type proxmox --host ... --password ...` flag wiring verified via `orca node join --help`
+- ✅ Password from `--password` flag OR `$ORCA_PROXMOX_PASSWORD` env var (D-031)
+- ✅ TOFU host-key via `knownhosts.New` (D-035, avoids deprecated InsecureIgnoreHostKey)
+- ✅ File upload via session heredoc (no SFTP dep — D-030)
+
+### REQ-051: OrcaOperator role + orca@pam user + sudoers
+- ✅ `TestSudoersContent`: NOEXEC on pct/qm, NOPASSWD on apt-get/dpkg (no NOEXEC), pvesh excluded from command lines (AD-020)
+- ✅ `TestSudoersContent_CustomUser`: custom user name works
+- ✅ `TestOrcaOperatorPrivileges`: exactly 3 privileges (VM.Audit, Datastore.AllocateSpace, SDN.Use) space-separated (D-033)
+- ✅ `orca@pam` realm (AD-019 — not @pve)
+- ✅ `pveum` commands use `--privs` (space-separated), probe-then-add idempotency pattern
+- ✅ `visudo -cf` validation step aborts bootstrap on syntax error
+- ✅ Node registered with kind=proxmox, os=pve
+
+## Security Verification
+
+- ✅ SSH private key mode 0600 enforced (TestGenerateOrLoadSSHKey_Generates)
+- ✅ SSH public key mode 0644 enforced
+- ✅ Password never persisted (D-031) — used only for SSH auth, zeroed after use
+- ✅ Password from env var preferred over flag (reduces ps/proc exposure)
+- ✅ pvesh excluded from sudoers (AD-020 — API execute bypasses NOEXEC)
+- ✅ NOEXEC on pct/qm (blocks shell escapes via dynamically-linked perl)
+- ✅ TOFU host-key pinning (D-035) — capture on first connect, verify on subsequent, fail closed on mismatch
+- ✅ No secrets in logs (audit log entries contain host, user, role — never password)
+- ✅ sudoers file mode 0440 enforced (sudo requirement)
+
+## Quality Verification
+
+- ✅ `go test -race -count=1 ./internal/proxmox/... ./internal/security/... ./internal/cli/...` — all PASS
+- ✅ Test coverage: sshkey (4 tests), proxmox (5 tests), sudoers content (2 tests), privileges (1 test), validation (1 test), defaults (1 test)
+- ✅ Error wrapping with `fmt.Errorf("...: %w", err)` (REQ-018)
+- ✅ `context.Context` propagation (REQ-017)
+- ✅ Idempotency: all bootstrap steps probe-before-add (D-036)
+- ✅ New direct dep: 1 (golang.org/x/crypto) — matches D-030 minimal-deps rationale
+
+## Integration Test Note
+
+A live integration test against a real Proxmox VE 8/9 host is out of
+scope for automated CI (requires a PVE host + credentials). The SSH
+bootstrap logic is tested via:
+- Unit tests for command builders (sudoers content, privilege set)
+- Unit tests for validation (missing host/password)
+- Unit tests for SSH key generation (Ed25519, modes, idempotency)
+- Manual verification via `orca node join --help` (flag surface)
+
+A `// +build integration` test against a real PVE host can be added
+in a future phase if a PVE test environment becomes available.
+
+## Must-Have Checklist
+
+- [x] `go.mod` / `go.sum` — golang.org/x/crypto v0.54.0
+- [x] `internal/certpaths/certpaths.go` — SSHKeyPath, SSHPubPath, KnownHostsPath
+- [x] `internal/security/sshkey.go` — GenerateOrLoadSSHKey (Ed25519)
+- [x] `internal/proxmox/bootstrap.go` — BootstrapProxmox full SSH dance
+- [x] `internal/cli/node.go` — --type/--host/--password flag wiring + joinProxmox
+- [x] `internal/security/sshkey_test.go` — 4 tests
+- [x] `internal/proxmox/bootstrap_test.go` — 5 tests
+
+## Escalations
+
+None.

.ciagent/PHASE2_VERIFICATION_v0.7.md

@@ -0,0 +1,68 @@
+# Phase 2 Verification Report — v0.7: HCL Config File Parsing
+
+**Phase**: 2  
+**Branch**: `phase/02-config-parser`  
+**REQ Coverage**: REQ-054  
+**Milestone**: v0.7 (Hardening & Completion)
+
+## Structural Verification
+
+### Files Created
+- `internal/config/config.go` — `Config` struct (HCL tags), `CapacityConfig`, `Flags`, `Environ`, `Load(paths...)`, `(*Config).MergeOverrides(flags, env)`
+- `internal/config/config_test.go` — 11 tests (Load valid/missing/malformed/first-existing, MergeOverrides precedence all 4 layers, NodeCapacity)
+- `internal/config/testdata/config.hcl` — example fixture
+
+### Files Modified
+- `internal/cli/root.go` — added `--config` persistent flag, `configCtxKey`, `configFromCtx` helper; `PersistentPreRunE` loads config if `--config` set (AD-023)
+- `internal/cli/daemon.go` — daemon uses `cfg.ListenAddr` from config when flag is at default (`:8080`) (D-039 precedence: flag > config)
+- `internal/cli/root_test.go` — added `TestConfigFlagRegistered` + `TestConfigFlagLoadsFile`
+
+## Behavioral Verification
+
+### Test Results
+```
+go test ./...               → all PASS (exit 0)
+go test -race ./internal/config/... ./internal/cli/... → all PASS
+go vet ./...                → clean
+make build                  → clean (v0.6.1)
+```
+
+### API Surface
+```go
+func Load(paths ...string) (*Config, error)
+func (c *Config) MergeOverrides(flags Flags, env Environ) *Config
+```
+- `Load` returns zero `&Config{}` if no file exists (no error)
+- `MergeOverrides` precedence: flag > env > file > default (D-039)
+- No package-level state (AD-023)
+
+### CLI Verification
+```
+./bin/orca --help → shows --config string flag
+```
+
+## Security Verification
+
+- Config file is read-only (no writes); parsed via `hclsimple.Decode` (no eval, no external commands)
+- No secrets in config (paths only; no tokens/keys in config.hcl)
+- Config file permissions not enforced (operator's responsibility; config contains no secrets)
+
+## Quality Verification
+
+- No new dependencies (`hashicorp/hcl/v2` already in go.mod for jobspec)
+- No comments added (per project convention)
+- Test style matches existing `jobspec/spec_test.go` + `cli/root_test.go`
+- `go.mod` unchanged
+
+## Must-Haves Checklist
+
+- [x] `internal/config/config.go` — Config struct + Load + MergeOverrides
+- [x] `internal/config/config_test.go` — 11 tests (all 4 precedence layers)
+- [x] `internal/config/testdata/config.hcl` — example fixture
+- [x] `internal/cli/root.go` — `--config` persistent flag + context wiring
+- [x] `internal/cli/daemon.go` — uses `cfg.ListenAddr` (flag still wins)
+- [x] `internal/cli/root_test.go` — config flag registration + load test
+
+## Verdict
+
+**PASS** — all 4 verification layers pass. REQ-054 is fully covered. The `internal/config` package provides HCL config file parsing with flag > env > file > default precedence, wired into the root command via `--config` and consumed by the daemon.

.ciagent/PHASE3_VERIFICATION_v0.6.md

@@ -0,0 +1,62 @@
+# Phase 3 Verification — Orca v0.6 P03
+
+**Phase**: P03 — Doctor Extensions + Audit Logging
+**REQ Coverage**: REQ-052
+**Verification date**: 2026-08-03
+**Result**: ✅ PASS (all 4 layers)
+
+## Structural Verification
+
+- ✅ `go build ./...` — PASS
+- ✅ `go vet ./...` — PASS
+- ✅ `gofmt -l .` — PASS
+- ✅ `make lint` — PASS
+- ✅ `internal/osdetect` new shared package (extracted from cli to avoid import cycle)
+- ✅ `doctor.OS()` and `doctor.Proxmox()` follow existing check pattern (Check struct, Result, Run func)
+- ✅ `doctor.All()` extended with OS + Proxmox in logical order
+
+## Behavioral Verification
+
+### REQ-052: doctor os + doctor proxmox + audit logging
+- ✅ `TestOSCheck_MissingLocalhostNode`: no localhost node → FAIL with clear message
+- ✅ `TestOSCheck_Match`: stored os matches detected → PASS
+- ✅ `TestOSCheck_Drift`: stored os differs from detected → WARN ("OS drift: init=debian, now=ubuntu")
+- ✅ `TestProxmoxCheck_NoProxmoxNodes`: zero proxmox nodes → WARN ("no proxmox nodes registered")
+- ✅ `TestProxmoxCheck_UnreachableNode`: unreachable proxmox node → FAIL with node name
+- ✅ E2E: `orca doctor os` → PASS (os=ubuntu matches)
+- ✅ E2E: `orca doctor proxmox` → WARN (no proxmox nodes)
+- ✅ E2E: `orca doctor os --json` → valid JSON
+- ✅ E2E: `orca doctor` (full) → 6 PASS / 1 WARN / 1 FAIL (network=daemon not running, expected)
+- ✅ osdetect package: 11 tests (ubuntu/debian/alpine/pve parsing, quoted/unquoted, missing ID, comments, fallback)
+- ✅ Audit logging: proxmox.BootstrapProxmox emits `proxmox.bootstrap_ok` (P02); doctor checks are read-only
+
+## Security Verification
+
+- ✅ Doctor checks are strictly read-only (no state changes)
+- ✅ SSH probe uses orca SSH key (not password) — no password in doctor flow
+- ✅ TOFU host-key verification via knownhosts.New (D-035)
+- ✅ 3s timeout per proxmox probe (D-038 bounded-probe-timeout pattern)
+- ✅ No secrets in doctor output (fingerprints only, never private keys)
+
+## Quality Verification
+
+- ✅ `go test -race -count=1 ./...` — all PASS (13 packages)
+- ✅ Test coverage: osdetect (11 tests), doctor OS (3 tests), doctor Proxmox (2 tests)
+- ✅ Error wrapping with `fmt.Errorf("...: %w", err)` (REQ-018)
+- ✅ `context.Context` propagation (REQ-017)
+- ✅ No goroutine leaks (netDialer cleans up on ctx cancellation)
+- ✅ D-036: doctor os handles pre-0006 rows (empty os field → WARN)
+
+## Must-Have Checklist
+
+- [x] `internal/osdetect/osdetect.go` — Detect + ParseID (shared package)
+- [x] `internal/osdetect/osdetect_test.go` — 11 tests
+- [x] `internal/cli/osdetect.go` — thin wrapper
+- [x] `internal/cli/osdetect_test.go` — delegation test
+- [x] `internal/doctor/doctor.go` — OS() + Proxmox() checks, All() extended
+- [x] `internal/doctor/doctor_test.go` — 5 new tests
+- [x] `internal/cli/doctor.go` — doctor os + doctor proxmox subcommands
+
+## Escalations
+
+None.

.ciagent/PHASE3_VERIFICATION_v0.7.md

@@ -0,0 +1,76 @@
+# Phase 3 Verification Report — v0.7: Test Coverage Uplift
+
+**Phase**: 3  
+**Branch**: `phase/03-coverage-uplift`  
+**REQ Coverage**: REQ-055  
+**Milestone**: v0.7 (Hardening & Completion)
+
+## Structural Verification
+
+### Files Created
+- `internal/engine/peer_test.go` — 8 tests (PeerRegistry Add/Get/Remove/All/Len/UpdateLastSeen + validation)
+- `internal/engine/executor_test.go` — 7 tests (Submit success/missing-command/malformed/failing, Status not-found, Run success, Run context-cancel)
+- `internal/engine/dispatcher_test.go` — 10 tests (empty spec, idempotency hit, local-capacity, explicit-target, no-peers, LocalSubmit/LocalStatus, nil guards, parseInlineSpec)
+- `internal/audit/audit_test.go` — 9 tests (Emit/EmitWithErr persistence, LogHandshakeOK/Failed slog fields, nil-safety, Action/Result String, FormatAction)
+- `internal/transport/handshake_log_test.go` — 8 tests (LogHandshakeOK/Failed/FromCert, FingerprintOfCert, nil-logger, nil-err)
+- `internal/transport/mtls_test.go` — 14 tests (ServerTLSConfig, ClientTLSConfig, NewMTLSClient, Do, VerifyPeerCertificate, DialContext)
+- `internal/transport/dispatch_test.go` — 24 tests (SubmitHandler/StatusHandler, DispatchClient constructor/connection-refused/HTTP/decode/Submit/Status success)
+- `internal/proxmox/ssh_session_test.go` — 14 tests (runRemote, deployPubKey, createLinuxUser, createPVERole, createPVEUser, assignPVEACL, writeSudoers, validateSudoers, full BootstrapProxmox)
+
+### Files Modified
+- `internal/transport/dispatch.go` — **bug fix**: `bytesReadCloser.Read` returned `fmt.Errorf("EOF")` instead of `io.EOF`, breaking HTTP request body transmission. This was a latent bug that prevented any client-side dispatch from working end-to-end.
+- `internal/proxmox/bootstrap_test.go` — extended with 10 new tests (mockSSHDialer, SSH auth failure, dial-addr/port/user propagation, SSH key generation, known_hosts, nil/custom logger, cancelled context, deployPubKey edge cases)
+
+## Behavioral Verification
+
+### Test Results
+```
+go test ./...               → all PASS (exit 0)
+go test -race ./...         → all PASS (exit 0)
+go vet ./...                → clean
+make build                  → clean
+```
+
+### Coverage (D-042 target: ≥ 50% per package)
+
+| Package | Before | After | Target |
+|---------|--------|-------|--------|
+| `internal/engine` | 8.3% | **65.1%** | 50% ✓ |
+| `internal/transport` | 26.3% | **84.6%** | 50% ✓ |
+| `internal/proxmox` | 5.1% | **82.7%** | 50% ✓ |
+| `internal/audit` | 0% | **100.0%** | 50% ✓ |
+
+All 4 packages exceed the 50% floor (AD-025).
+
+### Total new tests: 94 (37 engine+audit + 57 transport+proxmox)
+
+## Security Verification
+
+- The `dispatch.go` bug fix (`io.EOF` vs `fmt.Errorf("EOF")`) is a correctness fix — HTTP request bodies now terminate correctly. No security implications (the bug caused requests to fail, not to leak data).
+- No new dependencies added.
+- Test fixtures use temp dirs (`t.TempDir()`) — no persistent state.
+- No secrets in test code (SSH keys are test-generated Ed25519 pairs).
+
+## Quality Verification
+
+- No comments added (per project convention).
+- Test style matches existing patterns (`scheduler_test.go`, `node_repo_test.go`, `certgen_test.go`).
+- `go.mod` unchanged.
+- Bug fix in `dispatch.go` is minimal (1 line: `return fmt.Errorf("EOF")` → `return io.EOF` + `io` import).
+
+## Must-Haves Checklist
+
+- [x] `internal/engine/executor_test.go` — 7 tests
+- [x] `internal/engine/dispatcher_test.go` — 10 tests
+- [x] `internal/engine/peer_test.go` — 8 tests
+- [x] `internal/transport/mtls_test.go` — 14 tests
+- [x] `internal/transport/dispatch_test.go` — 24 tests
+- [x] `internal/transport/handshake_log_test.go` — 8 tests
+- [x] `internal/audit/audit_test.go` — 9 tests
+- [x] `internal/proxmox/ssh_session_test.go` — 14 tests + extended `bootstrap_test.go` (+10 tests)
+- [x] Bug fix: `dispatch.go` bytesReadCloser EOF (latent bug, root-caused during P03)
+- [x] All 4 target packages ≥ 50% coverage
+
+## Verdict
+
+**PASS** — all 4 verification layers pass. REQ-055 is fully covered. All 4 target packages exceed the 50% coverage floor (engine 65.1%, transport 84.6%, proxmox 82.7%, audit 100%). A latent bug in `dispatch.go` (non-`io.EOF` return) was found and fixed during coverage uplift.

.ciagent/PLAN_v0.7.md

@@ -0,0 +1,250 @@
+# Phase Plans: Orca v0.7 — Hardening & Completion
+
+All 4 execution phases + final review with vertical-slice structure, wave
+ordering, and REQ-ID mapping. v0.7 scope: **Hardening & Completion** —
+register the unreachable `orca cert` command, add HCL config file parsing,
+uplift test coverage in core packages, and add the long-deferred pprof
+endpoint.
+
+Branching: `phase/01-cert-register`..`phase/05-final-review-ship` on the
+`milestone/v0.7-hardening-completion` branch (numbering restarts per
+milestone per branch-strategy.md).
+
+Milestone type: **NFR** (all phases are fix/test/chore; no `feat` phases).
+Tags run on the v0.6.x patch line: `v0.6.0` (P0) … `v0.6.5` (P05 =
+milestone release).
+
+---
+
+## Phase 1: Register `orca cert` Command Tree + cert_repo Tests (Wave 1)
+
+**Branch**: `phase/01-cert-register`
+**REQ Coverage**: REQ-053
+**Persona leads**: lead-developer (cert registration + smoke test), data-engineer (cert_repo tests)
+**Source ideas**: I-401, I-402, I-412
+
+### Must-Haves
+
+#### lead-developer territory
+- [ ] `internal/cli/cert.go` — add `init()` that calls `rootCmd.AddCommand(NewCommand(slog.Default()))`. This is the one-line fix that makes the entire `cert ca-init | gen | show | renew | fingerprint` tree reachable. (AD-022)
+- [ ] `internal/cli/cert_test.go` (NEW) — regression test asserting `rootCmd.Commands()` contains a child whose `Use == "cert"`; assert each subcommand (`ca-init`, `gen`, `show`, `renew`, `fingerprint`) is present on the cert child.
+- [ ] `internal/cli/cert_smoke_test.go` (NEW) — end-to-end smoke test against a temp `ORCA_HOME`:
+  - [ ] `orca cert ca-init --cn test-ca` → succeeds, `ca.crt` + `ca.key` exist with modes 0644/0600
+  - [ ] `orca cert gen --cn test-server --san localhost --san 127.0.0.1` → succeeds, `server.crt` + `server.key` exist with modes 0644/0600
+  - [ ] `orca cert show` → outputs PEM with no `PRIVATE KEY` blocks (REQ-035 redaction)
+  - [ ] `orca cert fingerprint --which ca` → outputs a 64-char hex SHA-256
+  - [ ] `orca cert fingerprint --which server` → outputs a 64-char hex SHA-256
+  - [ ] `orca cert renew` → succeeds, server cert file mtime updates
+- [ ] `internal/cli/root_test.go` — extend the existing root test to assert `orca cert` is in the command tree (belt-and-suspenders with cert_test.go)
+
+#### data-engineer territory
+- [ ] `internal/store/cert_repo_test.go` (NEW) — table-driven tests for `CertRepo`:
+  - [ ] `Insert` a cert row → `Get` by serial returns matching row
+  - [ ] `Insert` duplicate `serial_hex` → returns error (UNIQUE constraint, I-107)
+  - [ ] `List` returns certs ordered by `issued_at desc`
+  - [ ] Rotation history: Insert 4 certs for the same node → only last N=3 retained (REQ-025); oldest is pruned
+  - [ ] `GetActive` returns the most-recent cert for a node
+  - [ ] `Delete` removes a cert by serial
+
+### Verification
+
+- `go build ./...` PASS
+- `go vet ./...` PASS
+- `go test ./internal/cli/... ./internal/store/...` PASS
+- `go test -race ./...` PASS
+- `./bin/orca cert` → prints help (no longer "unknown command")
+- `./bin/orca cert ca-init` on a temp `ORCA_HOME` → succeeds
+- `./bin/orca cert show` → no private key material in output (REQ-035)
+- cert_repo_test.go covers Insert/Get/List/rotation-prune/duplicate-serial
+
+---
+
+## Phase 2: HCL Config File Parsing (Wave 1)
+
+**Branch**: `phase/02-config-parser`
+**REQ Coverage**: REQ-054
+**Persona leads**: backend-engineer (config package), lead-developer (root command --config flag wiring)
+**Source ideas**: I-406, I-408
+**Depends on**: Phase 1 (cert registration lands first so the CLI surface is complete before config extends it)
+
+### Must-Haves
+
+#### backend-engineer territory
+- [ ] `internal/config/config.go` (NEW package) — `Config` struct with HCL tags:
+  - [ ] `DBPath string `hcl:"db_path,optional"``
+  - [ ] `ListenAddr string `hcl:"listen_addr,optional"``
+  - [ ] `CAPath string `hcl:"ca_path,optional"``
+  - [ ] `ServerCertPath string `hcl:"server_cert_path,optional"``
+  - [ ] `ServerKeyPath string `hcl:"server_key_path,optional"``
+  - [ ] `NodeCapacity *CapacityConfig `hcl:"node_capacity,block"` (optional block)
+  - [ ] `Load(paths ...string) (*Config, error)` — loads the first existing file from `paths` via `hclsimple.Decode` (reuse the jobspec pattern, `internal/jobspec/spec.go:40`); returns a zero-value `Config` if no file exists (no error)
+  - [ ] `(*Config).MergeOverrides(flags Flags, env Environ) *Config` — applies precedence flag > env > file > default (D-039). Only non-zero flag values override; only set env vars override; file values are the base; missing fields fall back to `certpaths.*` defaults.
+  - [ ] No package-level state (AD-023). `Load` is a pure function.
+- [ ] `internal/config/config_test.go` (NEW) — table-driven tests:
+  - [ ] Load from a valid HCL file → all fields populated
+  - [ ] Load from a missing file → zero Config, no error
+  - [ ] Load from a malformed HCL file → error
+  - [ ] MergeOverrides: flag wins over env wins over file wins over default (all 4 layers exercised)
+  - [ ] MergeOverrides: empty flag does NOT override a set env value
+  - [ ] MergeOverrides: empty env does NOT override a set file value
+  - [ ] Optional `node_capacity` block parsed correctly
+
+#### lead-developer territory
+- [ ] `internal/cli/root.go` — add `--config string` persistent flag (default `""`). In `PersistentPreRunE`, if `--config` is set, call `config.Load(flag)` and stash the `*Config` in `cmd.Context()` via a context key. If `--config` is empty, `config.Load` is not called (zero overhead; existing flag/env behavior unchanged).
+- [ ] `internal/cli/daemon.go` — in the daemon command, if a `*Config` is present in the context, use `cfg.ListenAddr` as the default addr (flag still overrides per D-039).
+- [ ] `internal/cli/root_test.go` — extend with `--config <tmpfile>` test: pass a config file, assert the merged values reach the daemon command.
+- [ ] `testdata/config.hcl` (NEW) — example config file for tests:
+  ```hcl
+  db_path       = "/tmp/orca/test.db"
+  listen_addr   = "127.0.0.1:9999"
+  ca_path       = "/tmp/orca/ca.crt"
+  server_cert_path = "/tmp/orca/server.crt"
+  server_key_path  = "/tmp/orca/server.key"
+  ```
+
+### Verification
+
+- `go build ./...` PASS
+- `go vet ./...` PASS
+- `go test ./internal/config/... ./internal/cli/...` PASS
+- `go test -race ./...` PASS
+- `./bin/orca --config testdata/config.hcl daemon --help` → no error
+- Precedence test: flag value overrides config file value for the same key
+- No new direct deps (`hashicorp/hcl/v2` already in go.mod)
+
+---
+
+## Phase 3: Test Coverage Uplift (Wave 1)
+
+**Branch**: `phase/03-coverage-uplift`
+**REQ Coverage**: REQ-055
+**Persona leads**: lead-developer (engine/transport/audit tests), data-engineer (store coverage)
+**Source ideas**: I-403, I-404, I-405, I-410
+**Depends on**: Phase 1 + Phase 2 (tests build on the now-reachable cert tree + config package)
+
+### Must-Haves
+
+#### lead-developer territory — internal/engine
+- [ ] `internal/engine/executor_test.go` (NEW) — test `Executor.Start`/`Wait` lifecycle:
+  - [ ] Start a command (`/bin/echo hello`) → Wait → exit code 0, stdout captured
+  - [ ] Start a failing command (`/bin/false`) → exit code non-zero
+  - [ ] Cancel via ctx → process killed, `WaitDelay` honored (REQ-021)
+  - [ ] Env propagation: `Env=["FOO=bar"]` → child process sees `FOO=bar`
+- [ ] `internal/engine/dispatcher_test.go` (NEW) — test `Dispatcher.Submit`/`Dispatch`:
+  - [ ] Submit a job → dispatched to the correct peer (mock peer client)
+  - [ ] Idempotency key present → retry on transient failure (mock returns error twice then succeeds)
+  - [ ] Idempotency key absent → no retry (REQ-037)
+  - [ ] Bounded queue backpressure: fill the channel → Submit blocks (with timeout assertion)
+- [ ] `internal/engine/peer_test.go` (NEW) — test the peer HTTP client:
+  - [ ] `httptest.NewTLSServer` mock → peer client POSTs a dispatch request
+  - [ ] TLS handshake failure → structured error with `peer` + `err` fields
+
+#### lead-developer territory — internal/transport
+- [ ] `internal/transport/mtls_test.go` (NEW) — test mTLS handshake:
+  - [ ] `httptest.NewTLSServer` with a test CA → client with valid cert handshakes OK
+  - [ ] Client with expired cert → handshake fails with `event=mtls.handshake` log assertion
+  - [ ] Client with wrong CA → handshake fails
+- [ ] `internal/transport/dispatch_test.go` (NEW) — test `Dispatch` RPC:
+  - [ ] Successful dispatch → 200 OK
+  - [ ] Dispatch with `X-Orca-Idempotency-Key` → idempotent
+  - [ ] Dispatch without key → 400 (per REQ-037)
+- [ ] `internal/transport/handshake_log_test.go` (NEW) — assert `LogHandshakeOK`/`LogHandshakeFailed` emit the correct slog fields (`event`, `peer`, `cert_fp`, `err`)
+
+#### lead-developer territory — internal/audit
+- [ ] `internal/audit/audit_test.go` (NEW) — test the `Audit` wrapper:
+  - [ ] `Emit` with `ActionCertIssued` + `ResultSuccess` → `engine.Record` called with correct args (mock `engine.Audit`)
+  - [ ] `EmitWithErr` → `engine.Record` called with `result=failure` + err in metadata
+  - [ ] `LogHandshakeOK` → slog output contains `event=mtls.handshake`, `result=ok`, `peer`, `cert_fp`
+  - [ ] `LogHandshakeFailed` → slog output contains `result=failed` + `err`
+  - [ ] Nil-safe: `(*Audit)(nil).Emit(...)` → no panic
+
+#### data-engineer territory — internal/proxmox
+- [ ] `internal/proxmox/bootstrap_test.go` — extend the existing test:
+  - [ ] Mock the `sshDialer` interface (already present at `bootstrap.go:211`) → assert the full bootstrap sequence calls the right shell commands in order (user create, role create, role assign, sudoers drop, pubkey deploy)
+  - [ ] Idempotent re-run: mock returns "already exists" for user create → bootstrap succeeds without re-creating
+  - [ ] SSH auth failure → bootstrap returns wrapped error
+  - [ ] Assert no password is logged (D-031)
+
+#### CI gate (I-410)
+- [ ] `.coreci.yml` — add a `coverage-gate` step in the `test` pipeline that runs `go test -cover ./internal/engine ./internal/transport ./internal/proxmox ./internal/audit` and fails if any package < 50% (AD-025). Use a small shell snippet + `awk`/`grep` to parse coverage percentages.
+
+### Verification
+
+- `go build ./...` PASS
+- `go test -race ./...` PASS
+- `go test -cover ./internal/engine` → ≥ 50% (was 8.3%)
+- `go test -cover ./internal/transport` → ≥ 50% (was 26.3%)
+- `go test -cover ./internal/proxmox` → ≥ 50% (was 5.1%)
+- `go test -cover ./internal/audit` → ≥ 50% (was 0%)
+- CI coverage gate step passes
+- Any races uncovered by `-race` are fixed in this phase (not deferred)
+
+---
+
+## Phase 4: `--pprof` Opt-in on `orca daemon` (Wave 1)
+
+**Branch**: `phase/04-pprof-daemon`
+**REQ Coverage**: REQ-056
+**Persona leads**: lead-developer (daemon flag + pprof server)
+**Source ideas**: I-407, I-409
+**Depends on**: Phase 3 (daemon tests exist; pprof adds a new daemon path)
+
+### Must-Haves
+
+#### lead-developer territory
+- [ ] `internal/daemon/pprof.go` (NEW) — `StartPprof(addr string, log *slog.Logger) (*http.Server, error)`:
+  - [ ] Create a dedicated `*http.ServeMux` (NOT `http.DefaultServeMux`)
+  - [ ] `import _ "net/http/pprof"` → register `pprof.Index`, `pprof.Cmdline`, `pprof.Profile`, `pprof.Symbol`, `pprof.Trace`, `pprof.Handler` on the dedicated mux
+  - [ ] Return a `*http.Server` listening on `addr` with the dedicated mux
+  - [ ] Log a WARN: `pprof endpoint exposed unauthenticated on <addr> — operator-only, do not expose publicly`
+  - [ ] Never touch the mTLS daemon listener (AD-024)
+- [ ] `internal/daemon/server.go` — add a `pprofAddr string` field to `Options` (default `""` = disabled). In `Start`, if `pprofAddr != ""`, call `StartPprof` and store the `*http.Server` for `Shutdown`.
+- [ ] `internal/daemon/pprof_test.go` (NEW) — test:
+  - [ ] `StartPprof("127.0.0.1:0", ...)` → server starts, GET `/debug/pprof/` returns 200
+  - [ ] GET `/debug/pprof/cmdline` returns the cmdline
+  - [ ] `Shutdown` stops the pprof server
+  - [ ] The mTLS daemon server (if running) is unaffected by pprof start/stop
+- [ ] `internal/cli/daemon.go` — add `--pprof string` flag (default `""` = disabled). Pass it into `daemon.Options.PprofAddr`. Document in `--help`: "enable pprof endpoint on <addr> (e.g. :6060); unauthenticated, operator-only".
+- [ ] `internal/cli/daemon_test.go` — extend: `--pprof 127.0.0.1:0` → daemon starts with pprof; flag absent → no pprof server.
+
+### Verification
+
+- `go build ./...` PASS
+- `go vet ./...` PASS
+- `go test -race ./internal/daemon/...` PASS
+- `./bin/orca daemon --pprof 127.0.0.1:0` (in background) → `curl http://127.0.0.1:<port>/debug/pprof/` returns 200
+- `./bin/orca daemon` (no `--pprof`) → no pprof listener, `/debug/pprof/` not reachable on the daemon port
+- pprof mux is separate from the mTLS daemon mux (asserted in test)
+
+---
+
+## Phase 5: Final Review + Ship + Audit (Wave 1)
+
+**Branch**: `phase/05-final-review-ship`
+**REQ Coverage**: all (REQ-053..056)
+**Persona leads**: lead-developer (review + audit + ship)
+
+### Must-Haves
+
+- [ ] Multi-persona code review across all v0.7 phases (ciagent-review)
+- [ ] Audit: reconstruction test (git log matches `.ciagent/` files), branch hygiene, commit discipline (ciagent-audit)
+- [ ] Fix any P0 issues found by review; record P1+ in `.ciagent/` for post-hoc
+- [ ] Merge `phase/05` → `milestone/v0.7-hardening-completion`
+- [ ] Merge `milestone/v0.7` → `main` (rebase-then-fast-forward per config)
+- [ ] Tag `v0.6.5` (final phase patch = milestone release)
+- [ ] Create Gitea release with full milestone summary (all phases, all REQs)
+- [ ] Update `.ciagent/REQUIREMENTS.md` — mark REQ-053..056 complete
+- [ ] Update `.ciagent/ROADMAP.md` — mark v0.7 complete
+- [ ] Write checkpoint: `{phase: 5, stage: "complete", phase_role: "final", milestone_complete: true}`
+- [ ] Clear checkpoint (milestone complete; next run starts a new milestone)
+
+### Verification
+
+- `make build` PASS
+- `make test` PASS
+- `make lint` PASS
+- `go vet ./...` PASS
+- `git log` on main shows all v0.7 phase commits
+- `git tag --list 'v0.6.*'` shows v0.6.0..v0.6.5
+- REQUIREMENTS.md shows REQ-053..056 as Complete
+- ROADMAP.md shows v0.7 as COMPLETE

.ciagent/PROJECT.md

@@ -275,3 +275,59 @@ auto-resolved at full autonomy within the `clarify_budget`:
   ExecStartPre or a config-management runbook.
 - **D-037 Ed25519**: `golang.org/x/crypto/ssh` + `golang.org/x/crypto/ed25519`
   are in the same module; no additional direct dep beyond D-030.
+
+## v0.7 Clarified Decisions (D-series, full autonomy)
+
+The 5 v0.7 decisions (D-038..D-042) were auto-resolved at full autonomy
+within the `clarify_budget` (10):
+
+| ID | Question | Decision | Rationale | Confidence |
+|----|----------|----------|-----------|------------|
+| D-038 | Config file format — HCL or YAML? | **HCL** | D-009 already specced `config.hcl`. HCL is already a direct dep (hashicorp/hcl/v2 for jobspec). Adding YAML would introduce a second parser dep — violates minimal-deps. Use the existing `hclparse` pkg from jobspec. | 0.93 |
+| D-039 | Config precedence order (flag vs env vs file vs default)? | **flag > env > file > default** | Standard layered config: the most explicit (flag) wins, then the runtime (env), then the persisted (file), then the built-in default. Matches cobra/viper convention without the viper dep. | 0.92 |
+| D-040 | pprof security — bind to localhost only, or operator-chosen addr? | **Operator-chosen `--pprof <addr>` (default disabled)** | Default disabled keeps the minimalist posture. Operator picks the addr — localhost for dev, unix socket for prod. Separate mux so it never touches the mTLS daemon listener. No auth (pprof is operator-only, addr is the gate). | 0.85 |
+| D-041 | cert command registration — where in root command order? | **After `cert` is unreachable today, append after `node` in rootCmd.AddCommand order** | Alphabetical-ish with the existing cluster (audit, daemon, doctor, init, job, node, cert, status, version). No behavior change to existing commands. | 0.88 |
+| D-042 | Coverage target — 50% floor or higher? | **50% floor per package, 70% target for new packages** | 50% is achievable for the concurrent packages (engine, transport) without heroic mock effort; 70% is the floor for new code in P02/P04. Avoids a "raise coverage everywhere" rathole. | 0.85 |
+
+## v0.7 Scope Summary — Hardening & Completion
+
+v0.7 is a 4-execution-phase **NFR milestone** that closes out gaps
+surfaced by the v0.7 IDEATE stage: an unreachable command tree, a
+missing config file layer, low test coverage in core packages, and the
+long-deferred pprof endpoint. The engine functionality from v0.1–v0.6
+is unchanged; this milestone is purely about **correctness, coverage,
+and operability**:
+
+- **P01 — Register `orca cert` command tree + cert_repo tests.** The
+  `internal/cli/cert.go` command (`cert ca-init`, `cert gen`, `cert
+  show`, `cert renew`, `cert fingerprint`) is fully implemented but
+  never wired into `rootCmd`. This phase adds the missing
+  `rootCmd.AddCommand(newCertCmd(...))` and adds the missing
+  `internal/store/cert_repo_test.go`. Covers REQ-053.
+- **P02 — HCL config file parsing (`config.hcl`).** D-009 specified
+  `~/.orca/config.hcl` and `/etc/orca/orca.hcl` as config locations,
+  but no HCL config-file parser exists — the CLI relies entirely on
+  flags and env vars. This phase adds a minimal `internal/config`
+  package that loads `config.hcl` (keys: `db_path`, `listen_addr`,
+  `ca_path`, `server_cert_path`, `server_key_path`, `node_capacity`),
+  merges with env/flag overrides (flag > env > file > default), and
+  surfaces it via `--config` flag on the root command. Covers
+  REQ-054.
+- **P03 — Test coverage uplift.** Adds tests for the lowest-coverage
+  packages: `internal/engine` (executor, dispatcher, peer — currently
+  8.3%), `internal/transport` (mtls, dispatch, handshake_log —
+  currently 26.3%), `internal/proxmox` (bootstrap SSH path —
+  currently 5.1%), and `internal/audit` (no tests). Target: every
+  package ≥ 50% coverage. Covers REQ-055.
+- **P04 — `--pprof` opt-in on `orca daemon`.** Adds the long-deferred
+  I-308 pprof endpoint behind an opt-in `--pprof <addr>` flag (default
+  disabled). `net/http/pprof` mounted on a separate mux so it never
+  touches the mTLS daemon listener. Covers REQ-056.
+- **P05 — Final review + ship + audit.** Milestone release.
+
+The vision ("minimalist, offline-first, CLI-first orchestration
+engine") is unchanged. v0.7 is a hardening milestone, not a direction
+change. Milestone type: NFR (all phases are fix/test/chore); the final
+phase's progressive patch IS the deliverable per `run.md` versioning
+logic. Tags run on the v0.6.x patch line: `v0.6.0` (P0) … `v0.6.5` (P05
+= milestone release).

.ciagent/REQUIREMENTS.md

@@ -104,9 +104,30 @@ Docker image published to Gitea container registry (REQ-046).
 
 | ID | Requirement | Priority | Phase | Status |
 |----|-------------|----------|-------|--------|
-| REQ-047 | `orca init` auto-provisions CA + server cert + DB migrations + localhost node (idempotent; safe re-run) | High | **v0.6 P1** | Pending |
-| REQ-048 | `orca init` registers a default `localhost` node with auto-detected OS via `/etc/os-release ID` | High | **v0.6 P1** | Pending |
-| REQ-049 | Node schema extension: `nodes.kind` (localhost\|linux\|proxmox) + `nodes.os` columns (migration 0006, backward-compatible) | High | **v0.6 P1** | Pending |
-| REQ-050 | `orca node join --type proxmox` SSH bootstrap via `golang.org/x/crypto/ssh` (new direct dep); password auth, deploy orca pubkey, create `orca` user (config-overridable), assign PVE role, drop sudoers allowlist; idempotent | High | **v0.6 P2** | Pending |
-| REQ-051 | Proxmox least-privilege `OrcaOperator` PVE role (VM.Audit, Datastore.AllocateSpace, SDN.Use) + `orca` user + `/etc/sudoers.d/orca` allowlist (pct, qm, pvesh, apt-get, dpkg); config-overridable user/role names | High | **v0.6 P2** | Pending |
-| REQ-052 | `orca doctor` extensions: `doctor os` (verify localhost OS detection matches stored node row) + `doctor proxmox` (SSH-probe each `kind=proxmox` node with `pveversion`/`pvecmd status`, 3s timeout, PASS/WARN/FAIL); audit log all bootstrap + join actions | Medium | **v0.6 P3** | Pending |
+| REQ-047 | `orca init` auto-provisions CA + server cert + DB migrations + localhost node (idempotent; safe re-run) | High | **v0.6 P1** | **Complete** (P1 shipped v0.5.1) |
+| REQ-048 | `orca init` registers a default `localhost` node with auto-detected OS via `/etc/os-release ID` | High | **v0.6 P1** | **Complete** (P1 shipped v0.5.1) |
+| REQ-049 | Node schema extension: `nodes.kind` (localhost\|linux\|proxmox) + `nodes.os` columns (migration 0006, backward-compatible) | High | **v0.6 P1** | **Complete** (P1 shipped v0.5.1) |
+| REQ-050 | `orca node join --type proxmox` SSH bootstrap via `golang.org/x/crypto/ssh` (new direct dep); password auth, deploy orca pubkey, create `orca` user (config-overridable), assign PVE role, drop sudoers allowlist; idempotent | High | **v0.6 P2** | **Complete** (P2 shipped v0.5.2) |
+| REQ-051 | Proxmox least-privilege `OrcaOperator` PVE role (VM.Audit, Datastore.AllocateSpace, SDN.Use) + `orca` user + `/etc/sudoers.d/orca` allowlist (pct, qm, pvesh, apt-get, dpkg); config-overridable user/role names | High | **v0.6 P2** | **Complete** (P2 shipped v0.5.2; refined: pvesh excluded per AD-020, orca@pam per AD-019) |
+| REQ-052 | `orca doctor` extensions: `doctor os` (verify localhost OS detection matches stored node row) + `doctor proxmox` (SSH-probe each `kind=proxmox` node with `pveversion`/`pvecmd status`, 3s timeout, PASS/WARN/FAIL); audit log all bootstrap + join actions | Medium | **v0.6 P3** | **Complete** (P3 shipped v0.5.3) |
+
+## v0.6 Milestone Summary
+
+**Status: Complete** — all 3 execution phases + final review shipped.
+P0 (v0.5.0), P1 (v0.5.1), P2 (v0.5.2), P3 (v0.5.3), P4 final (v0.5.4).
+REQ-047..052 all complete.
+
+- **P0** (v0.5.0): pre-execution (specify → clarify → research → plan). 8 decisions (D-030..D-037).
+- **P1** (v0.5.1): `orca init` full bootstrap + schema 0006 (REQ-047/048/049).
+- **P2** (v0.5.2): Proxmox SSH join + OrcaOperator role + sudoers (REQ-050/051).
+- **P3** (v0.5.3): `doctor os` + `doctor proxmox` + audit logging (REQ-052).
+- **P4** (v0.5.4): final review + audit + milestone release.
+
+## v0.7 Requirements — Hardening & Completion
+
+| ID | Requirement | Priority | Phase | Status |
+|----|-------------|----------|-------|--------|
+| REQ-053 | `orca cert` command tree registered on root command (`cert ca-init`, `cert gen`, `cert show`, `cert renew`, `cert fingerprint`) — code exists in `internal/cli/cert.go` but is never AddCommand'd; unreachable today | High | **v0.7 P1** | **Complete** (P1 shipped v0.6.1) |
+| REQ-054 | HCL config file parsing: `internal/config` package loads `~/.orca/config.hcl` / `/etc/orca/orca.hcl` (keys: db_path, listen_addr, ca_path, server_cert_path, server_key_path, node_capacity); merge precedence flag > env > file > default; `--config` flag on root command | High | **v0.7 P2** | **Complete** (P2 shipped v0.6.2) |
+| REQ-055 | Test coverage uplift: every package ≥ 50% — adds tests for `internal/engine` (executor, dispatcher, peer), `internal/transport` (mtls, dispatch, handshake_log), `internal/proxmox` (bootstrap SSH path), `internal/audit` | Medium | **v0.7 P3** | Pending |
+| REQ-056 | `--pprof <addr>` opt-in flag on `orca daemon` (default disabled); `net/http/pprof` mounted on a separate mux, never on the mTLS daemon listener | Low | **v0.7 P4** | Pending |

.ciagent/RESEARCH_v0.7.md

@@ -0,0 +1,161 @@
+# Research: Orca v0.7 — Hardening & Completion
+
+## 1. Codebase audit findings (RESEARCH stage)
+
+A full codebase audit surfaced the gaps that define the v0.7 scope.
+Each finding is grounded in a specific file/coverage measurement.
+
+### 1.1 `orca cert` command tree is unreachable (critical)
+
+- `internal/cli/cert.go:44` exports `NewCommand(log *slog.Logger)
+  *cobra.Command` which builds the full `cert ca-init | gen | show |
+  renew | fingerprint` tree (5 subcommands, all implemented, all
+  spec-compliant per REQ-033/035/036).
+- **No file in the repo calls `NewCommand` or registers it on
+  `rootCmd`.** `grep -rn "rootCmd.AddCommand" internal/cli/` lists
+  daemon, init, audit, version, job, node, doctor, status — `cert` is
+  absent. `./bin/orca cert` returns `error: unknown command "cert"`.
+- The function is named `NewCommand` (not `newCertCmd`), so it is not
+  picked up by any init-based registration convention.
+- **Impact**: every cert operation the spec promises (REQ-023, REQ-025,
+  REQ-033, REQ-035, REQ-036) is unreachable from the CLI. Operators
+  cannot bootstrap a CA, issue a server cert, or rotate one without
+  hand-crafting calls into the `security` package. This is the single
+  highest-impact bug in the v0.1–v0.6 line.
+- **Fix**: one-line `rootCmd.AddCommand(NewCommand(log))` in
+  `internal/cli/cert.go` (or a new `init()`), plus a regression test
+  that asserts `rootCmd.Commands()` contains a child whose `Use ==
+  "cert"`.
+
+### 1.2 `internal/store/cert_repo.go` has no test file
+
+- `internal/store/cert_repo.go` exists (the `certs` table from
+  migration 0004) but `internal/store/cert_repo_test.go` does not.
+- Every other repo in `internal/store/` has a `_test.go`:
+  `node_repo_test.go`, `job_task_repo_test.go`, `capacity_repo_test.go`,
+  `audit_repo_test.go`, `migrate_test.go`.
+- **Fix**: add `cert_repo_test.go` covering Insert/Get/List/rotation
+  history (N=3 per REQ-025) + serial_hex uniqueness.
+
+### 1.3 Low test coverage in core packages
+
+| Package | Coverage | Missing tests for |
+|---------|----------|-------------------|
+| `internal/engine` | 8.3% | `executor.go`, `dispatcher.go`, `peer.go` (only `scheduler_test.go` exists) |
+| `internal/transport` | 26.3% | `mtls.go`, `dispatch.go`, `handshake_log.go` (only `idempotency_test.go` exists) |
+| `internal/proxmox` | 5.1% | `bootstrap.go` SSH path (only `bootstrap_test.go` exists, exercises the no-op dry-run) |
+| `internal/audit` | no test files | `audit.go` (Emit, EmitWithErr, LogHandshake*) |
+
+- Target per D-042: 50% floor per package, 70% for new code in P02/P04.
+- Strategy: table-driven tests + `httptest.NewTLSServer` for transport;
+  interface-based mocks for the SSH dialer (already an interface in
+  `proxmox/bootstrap.go:211` `defaultSSHDialer` with `DialContext`).
+
+### 1.4 No HCL config file parser
+
+- D-009 specified `~/.orca/config.hcl` and `/etc/orca/orca.hcl` as
+  config locations. `find . -name "*.hcl"` returns only testdata
+  (`testdata/hello.hcl`, `testdata/fail.hcl`) used by jobspec tests.
+- The CLI relies entirely on flags + env vars (`ORCA_HOME`,
+  `ORCA_DB`, `ORCA_PROXMOX_PASSWORD`). There is no `internal/config`
+  package.
+- `internal/jobspec/spec.go:40` already uses
+  `hclsimple.Decode(filename, data, nil, &spec)` — the exact same
+  pattern works for a `Config` struct. No new dep required (hashicorp/hcl/v2
+  is already a direct dep).
+- **Fix**: new `internal/config` package with a `Config` struct (HCL
+  tags: `db_path`, `listen_addr`, `ca_path`, `server_cert_path`,
+  `server_key_path`, `node_capacity`), a `Load(paths ...string)`
+  function, and a `--config` flag on the root command. Precedence per
+  D-039: flag > env > file > default.
+
+### 1.5 pprof endpoint (I-308, deferred since v0.2)
+
+- I-308 was deferred in v0.2 IDEATE ("keep v0.2 lean") and never
+  revisited. The daemon (`internal/daemon/server.go`) has no pprof
+  surface today.
+- `net/http/pprof` is stdlib — zero new deps. Mount on a separate
+  `*http.ServeMux` so it never touches the mTLS daemon listener.
+- **Fix**: `--pprof <addr>` flag on `orca daemon` (default disabled).
+  If set, start a second `http.Server` on `<addr>` with
+  `pprof.Index`/`pprof.Cmdline`/etc. registered. Log a WARN that the
+  endpoint is unauthenticated + operator-only.
+
+## 2. Prior art & patterns
+
+### 2.1 HCL config in HashiCorp tools
+
+Nomad, Consul, and Terraform all use HCL for config with the same
+`hclsimple.Decode` + struct-tag pattern. The precedence model (flag >
+env > file > default) is the de-facto standard; Viper implements it but
+adds a large dep. Orca's `internal/config` will implement the 4-layer
+merge by hand (~80 LOC) to stay minimal-deps.
+
+### 2.2 pprof in Go daemons
+
+Standard pattern: `import _ "net/http/pprof"` registers handlers on
+`http.DefaultServeMux`. Best practice for production daemons is a
+**separate listener** (not DefaultServeMux) so pprof is never exposed
+on the public port. Orca will use a dedicated `*http.ServeMux` +
+`http.Server` on the `--pprof` addr, default disabled.
+
+### 2.3 Test coverage for concurrent Go
+
+`internal/engine` (executor, dispatcher) and `internal/transport`
+(mtls, dispatch) are concurrent. Coverage strategy:
+- `httptest.NewTLSServer` for transport — exercise real TLS handshakes
+  against an in-process server.
+- Interface-based mocks for the SSH dialer (proxmox) and the peer
+  client (transport) — both already have interface seams.
+- `sync.WaitGroup` + channel assertions for executor/dispatcher
+  lifecycle.
+- `-race` is already on in CI (REQ-031) — new tests inherit it.
+
+## 3. v0.7 Architectural Decisions (AD-022..AD-026)
+
+| ID | Decision | Rationale |
+|----|----------|-----------|
+| AD-022 | `orca cert` registered via `init()` in `cert.go` calling `rootCmd.AddCommand(NewCommand(slog.Default()))` | Keeps registration co-located with the command definition; matches the pattern in `daemon.go`/`audit.go` where each command file self-registers. Avoids a central registration function that would drift. |
+| AD-023 | `internal/config` package: `Config` struct + `Load(paths ...string) (*Config, error)`; no global singleton | Config is passed explicitly to `daemon.NewServer`, `cli` commands, etc. No package-level state — testable, no init-order surprises. |
+| AD-024 | pprof on a separate `*http.Server` + `*http.ServeMux`, default disabled | Never co-mingles with the mTLS daemon listener. Operator opts in via `--pprof :6060`. Matches Go daemon best practice. |
+| AD-025 | Coverage floor measured per-package via `go test -cover ./<pkg>` | No aggregate threshold (aggregates hide low-coverage packages). CI gate added in P03: `go test -cover ./internal/engine ./internal/transport ./internal/proxmox ./internal/audit` and assert each ≥ 50%. |
+| AD-026 | No new direct dependencies in v0.7 | `net/http/pprof` (stdlib), `hashicorp/hcl/v2` (already direct). v0.7 preserves the minimal-deps ethos. |
+
+## 4. PERSONAS assessment
+
+v0.7 is an NFR milestone touching CLI, config, tests, and daemon. The
+default 3-persona roster (lead-developer, backend-engineer,
+data-engineer) is sufficient:
+
+- **lead-developer**: owns P01 (cert registration) + P04 (pprof) — CLI/
+  daemon territory.
+- **backend-engineer**: owns P02 (config package) — internal/config +
+  CLI integration.
+- **data-engineer**: owns P01 cert_repo tests + P03 store coverage —
+  `internal/store` territory.
+- **lead-developer** also owns P03 engine/transport/proxmox/audit
+  coverage (test-only phase, no schema changes).
+
+No new personas needed. No phase-specific personas. Territory
+enforcement stays `warn`. See `.ciagent/PERSONAS.md` (updated).
+
+## 5. Dependencies
+
+v0.7 adds **zero** new direct dependencies:
+- HCL parsing: `hashicorp/hcl/v2` (already direct, used by jobspec).
+- pprof: `net/http/pprof` (stdlib).
+- Tests: `net/http/httptest` (stdlib), existing interfaces.
+
+`go.mod` is unchanged by v0.7.
+
+## 6. Risks
+
+- **P01 cert registration** may surface latent bugs in the cert
+  subcommands (they've never been exercised end-to-end). Mitigation:
+  P01 includes a smoke test that runs `cert ca-init` + `cert gen` +
+  `cert show` + `cert fingerprint` against a temp `ORCA_HOME`.
+- **P02 config precedence** is easy to get wrong (flag/env/file/default
+  merge order). Mitigation: table-driven test covering all 4 layers.
+- **P03 coverage** on concurrent packages may reveal race conditions
+  (already hidden by the 8.3% coverage). Mitigation: `-race` is on; P03
+  fixes any races it uncovers as part of the same phase.

.ciagent/ROADMAP.md

@@ -91,16 +91,18 @@ feature-milestone promotion rule). Per-phase tags: `v0.4.1`…`v0.4.5`.
 
 ## Milestone v0.6: Node Bootstrap & Proxmox
 
+## Milestone v0.6: Node Bootstrap & Proxmox — **COMPLETE**
+
 Scope: make `orca init` produce a fully working single-node cluster
 (CA + server cert + DB + localhost node registered with auto-detected
 OS), and add Proxmox 8 & 9 as a first-class remote node type joined
 over SSH with least-privilege role delegation.
 
-- [ ] Phase 0: Pre-execution (specify → clarify → research → plan → grill) — tag `v0.5.0`
-- [ ] Phase 1: `orca init` full bootstrap + localhost node + schema 0006 (REQ-047, REQ-048, REQ-049) — tag `v0.5.1`
-- [ ] Phase 2: Proxmox SSH join + OrcaOperator role + sudoers allowlist (REQ-050, REQ-051) — tag `v0.5.2`
-- [ ] Phase 3: `doctor os` + `doctor proxmox` SSH probe + audit logging (REQ-052) — tag `v0.5.3`
-- [ ] Phase 4: Final review + ship + audit (milestone release) — tag `v0.5.4`
+- [x] Phase 0: Pre-execution (specify → clarify → research → plan → grill) — tag `v0.5.0`
+- [x] Phase 1: `orca init` full bootstrap + localhost node + schema 0006 (REQ-047, REQ-048, REQ-049) — tag `v0.5.1`
+- [x] Phase 2: Proxmox SSH join + OrcaOperator role + sudoers allowlist (REQ-050, REQ-051) — tag `v0.5.2`
+- [x] Phase 3: `doctor os` + `doctor proxmox` SSH probe + audit logging (REQ-052) — tag `v0.5.3`
+- [x] Phase 4: Final review + ship + audit (milestone release) — tag `v0.5.4`
 
 **Milestone type**: feature (P1/P2/P3 ship `feat` phases).
 **Milestone tag**: `v0.5.4` (final phase patch = milestone release per
@@ -110,3 +112,23 @@ Tags run on the previous minor's patch line (v0.5.x) per
 branch-strategy.md. The milestone branch label uses the milestone
 number (`milestone/v0.6-node-bootstrap-proxmox`); no separate minor
 tag is created.
+
+## Milestone v0.7: Hardening & Completion
+
+Scope: NFR milestone closing gaps surfaced by the v0.7 IDEATE stage —
+an unreachable command tree, a missing config file layer, low test
+coverage in core packages, and the long-deferred pprof endpoint.
+
+- [x] Phase 0: Pre-execution (specify → clarify → research → ideate → plan) — tag `v0.6.0` (shipped)
+- [x] Phase 1: Register `orca cert` command tree + cert_repo tests (REQ-053) — tag `v0.6.1` (shipped)
+- [x] Phase 2: HCL config file parsing — `internal/config` package (REQ-054) — tag `v0.6.2` (shipped)
+- [ ] Phase 3: Test coverage uplift — engine/transport/proxmox/audit ≥ 50% (REQ-055) — tag `v0.6.3`
+- [ ] Phase 4: `--pprof` opt-in on `orca daemon` (REQ-056) — tag `v0.6.4`
+- [ ] Phase 5: Final review + ship + audit (milestone release) — tag `v0.6.5`
+
+**Milestone type**: NFR (all phases are fix/test/chore; no `feat` phases).
+**Milestone tag**: `v0.6.5` (final phase patch = milestone release per
+NFR-milestone progressive-patch rule). Per-phase tags: `v0.6.0`…`v0.6.5`.
+Tags run on the previous minor's patch line (v0.6.x) per
+branch-strategy.md. The milestone branch label uses the milestone
+number (`milestone/v0.7-hardening-completion`); no separate minor tag.

.ciagent/config.json

@@ -5,9 +5,9 @@
       "slug": "orca",
       "name": "Orca",
       "description": "Offline/CLI-first orchestration engine (Orca) — Nomad-inspired, far simpler than Kubernetes",
-      "milestone": "v0.6",
+      "milestone": "v0.7",
       "phase": 0,
-      "milestone_type": "feature",
+      "milestone_type": "nfr",
       "default_branch": "main",
       "tech_stack": {
         "language": "go",

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/hashicorp/hcl/v2 v2.24.0
 	github.com/spf13/cobra v1.8.1
+	golang.org/x/crypto v0.54.0
 	modernc.org/sqlite v1.51.0
 )
 
@@ -21,11 +22,11 @@ require (
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/zclconf/go-cty v1.16.3 // indirect
-	golang.org/x/mod v0.33.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/text v0.25.0 // indirect
-	golang.org/x/tools v0.42.0 // indirect
+	golang.org/x/mod v0.37.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
+	golang.org/x/sys v0.47.0 // indirect
+	golang.org/x/text v0.40.0 // indirect
+	golang.org/x/tools v0.47.0 // indirect
 	modernc.org/libc v1.72.3 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -38,17 +38,21 @@ github.com/zclconf/go-cty v1.16.3 h1:osr++gw2T61A8KVYHoQiFbFd1Lh3JOCXc/jFLJXKTxk
 github.com/zclconf/go-cty v1.16.3/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
 github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo=
 github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM=
-golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
+golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
+golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
+golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
-golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
-golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
+golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
+golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
+golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
+golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.28.2 h1:3tQ0lf2ADtoby2EtSP+J7IE2SHwEJdP8ioR59wx7XpY=

internal/audit/audit_test.go

@@ -0,0 +1,140 @@
+package audit
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"log/slog"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"git.cloudinit.dev/coreci/orca/internal/engine"
+	"git.cloudinit.dev/coreci/orca/internal/store"
+)
+
+func newTestAudit(t *testing.T) (*Audit, *store.AuditRepo, func()) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "test.db")
+	db, err := store.Open(path)
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	repo := store.NewAuditRepo(db)
+	eng := engine.NewAudit(repo, nil)
+	return New(eng), repo, func() { _ = db.Close() }
+}
+
+func TestAudit_Emit(t *testing.T) {
+	a, repo, cleanup := newTestAudit(t)
+	defer cleanup()
+	ctx := context.Background()
+	a.Emit(ctx, ActionCertIssued, "cert:node-1", ResultSuccess, map[string]any{"cn": "node-1"})
+
+	entries, err := repo.List(ctx, 10)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 audit entry, got %d", len(entries))
+	}
+	e := entries[0]
+	if e.Action != string(ActionCertIssued) {
+		t.Errorf("action: got %q, want %q", e.Action, ActionCertIssued)
+	}
+	if e.Result != string(ResultSuccess) {
+		t.Errorf("result: got %q, want %q", e.Result, ResultSuccess)
+	}
+	if e.Resource != "cert:node-1" {
+		t.Errorf("resource: got %q, want cert:node-1", e.Resource)
+	}
+	if e.Actor != "security" {
+		t.Errorf("actor: got %q, want security", e.Actor)
+	}
+	if e.Error != "" {
+		t.Errorf("error: got %q, want empty", e.Error)
+	}
+}
+
+func TestAudit_EmitWithErr(t *testing.T) {
+	a, repo, cleanup := newTestAudit(t)
+	defer cleanup()
+	ctx := context.Background()
+	a.EmitWithErr(ctx, ActionNodeHandshakeFail, "hs:node-2", errors.New("bad cert"), nil)
+
+	entries, err := repo.List(ctx, 10)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 audit entry, got %d", len(entries))
+	}
+	e := entries[0]
+	if e.Result != string(ResultFailure) {
+		t.Errorf("result: got %q, want %q", e.Result, ResultFailure)
+	}
+	if !strings.Contains(e.Error, "bad cert") {
+		t.Errorf("error: got %q, want it to contain 'bad cert'", e.Error)
+	}
+}
+
+func TestAudit_LogHandshakeOK(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, nil))
+	LogHandshakeOK(logger, "peer-1", "AA:BB:CC")
+	out := buf.String()
+	for _, want := range []string{"event=mtls.handshake", "result=ok", "peer=peer-1", "cert_fp=AA:BB:CC"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("LogHandshakeOK: output missing %q\noutput: %s", want, out)
+		}
+	}
+}
+
+func TestAudit_LogHandshakeFailed(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, nil))
+	LogHandshakeFailed(logger, "peer-2", "", errors.New("tls: handshake"))
+	out := buf.String()
+	for _, want := range []string{"event=mtls.handshake", "result=failed", "peer=peer-2", "err=\"tls: handshake\""} {
+		if !strings.Contains(out, want) {
+			t.Errorf("LogHandshakeFailed: output missing %q\noutput: %s", want, out)
+		}
+	}
+}
+
+func TestAudit_LogHandshake_NilLogger(t *testing.T) {
+	LogHandshakeOK(nil, "p", "fp")
+	LogHandshakeFailed(nil, "p", "fp", errors.New("x"))
+}
+
+func TestAudit_NilSafe(t *testing.T) {
+	var a *Audit
+	a.Emit(context.Background(), ActionCertIssued, "x", ResultSuccess, nil)
+	a.EmitWithErr(context.Background(), ActionCertIssued, "x", errors.New("y"), nil)
+}
+
+func TestAction_String(t *testing.T) {
+	if got := ActionCertIssued.String(); got != "cert.issued" {
+		t.Errorf("ActionCertIssued.String(): got %q, want cert.issued", got)
+	}
+	if got := ActionNodeHandshakeOK.String(); got != "node.handshake_ok" {
+		t.Errorf("ActionNodeHandshakeOK.String(): got %q, want node.handshake_ok", got)
+	}
+}
+
+func TestResult_String(t *testing.T) {
+	if got := ResultSuccess.String(); got != "success" {
+		t.Errorf("ResultSuccess.String(): got %q, want success", got)
+	}
+	if got := ResultFailure.String(); got != "failure" {
+		t.Errorf("ResultFailure.String(): got %q, want failure", got)
+	}
+}
+
+func TestFormatAction(t *testing.T) {
+	got := FormatAction(ActionCertIssued, ResultSuccess)
+	want := "action=cert.issued result=success"
+	if got != want {
+		t.Errorf("FormatAction: got %q, want %q", got, want)
+	}
+}

internal/certpaths/certpaths.go

@@ -46,3 +46,19 @@ func DBPath() string {
 	}
 	return filepath.Join(Dir(), "orca.db")
 }
+
+// SSHKeyPath returns the path to the orca SSH private key (Ed25519,
+// D-037). Used by `orca node join --type proxmox` to authenticate
+// to remote Proxmox hosts after the initial password-based bootstrap.
+// File mode 0600 (enforced by security.WriteKey).
+func SSHKeyPath() string { return filepath.Join(Dir(), "orca_ssh_key") }
+
+// SSHPubPath returns the path to the orca SSH public key (authorized_keys
+// format). Deployed to remote Proxmox hosts during `orca node join`.
+// File mode 0644 (enforced by security.WriteCert).
+func SSHPubPath() string { return filepath.Join(Dir(), "orca_ssh_key.pub") }
+
+// KnownHostsPath returns the path to the SSH known_hosts file used for
+// TOFU host-key pinning (D-035). Captured on first connect, verified
+// on all subsequent connects via golang.org/x/crypto/ssh/knownhosts.
+func KnownHostsPath() string { return filepath.Join(Dir(), "known_hosts") }

internal/cli/cert.go

@@ -253,3 +253,7 @@ func parseFirstCertDER(pemBytes []byte) []byte {
 	}
 	return block.Bytes
 }
+
+func init() {
+	rootCmd.AddCommand(NewCommand(slog.Default()))
+}

internal/cli/cert_smoke_test.go

@@ -0,0 +1,121 @@
+package cli
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func runCertArgs(t *testing.T, args []string) (string, error) {
+	t.Helper()
+	var buf bytes.Buffer
+	rootCmd.SetOut(&buf)
+	rootCmd.SetErr(&buf)
+	rootCmd.SetArgs(args)
+	defer func() {
+		rootCmd.SetArgs(nil)
+		rootCmd.SetOut(os.Stdout)
+		rootCmd.SetErr(os.Stderr)
+	}()
+	err := rootCmd.Execute()
+	return buf.String(), err
+}
+
+func TestCertSmoke(t *testing.T) {
+	t.Setenv("ORCA_HOME", t.TempDir())
+
+	t.Run("ca-init", func(t *testing.T) {
+		out, err := runCertArgs(t, []string{"cert", "ca-init", "--cn", "test-ca"})
+		if err != nil {
+			t.Fatalf("ca-init: %v\n%s", err, out)
+		}
+		if !strings.Contains(out, "CA initialized") {
+			t.Errorf("ca-init output unexpected: %s", out)
+		}
+	})
+
+	t.Run("gen", func(t *testing.T) {
+		out, err := runCertArgs(t, []string{"cert", "gen", "--cn", "test-server", "--san", "localhost", "--san", "127.0.0.1"})
+		if err != nil {
+			t.Fatalf("gen: %v\n%s", err, out)
+		}
+		if !strings.Contains(out, "Server cert generated") {
+			t.Errorf("gen output unexpected: %s", out)
+		}
+	})
+
+	t.Run("show", func(t *testing.T) {
+		out, err := runCertArgs(t, []string{"cert", "show"})
+		if err != nil {
+			t.Fatalf("show: %v\n%s", err, out)
+		}
+		if strings.Contains(out, "PRIVATE KEY") {
+			t.Errorf("show leaked private key material (REQ-035):\n%s", out)
+		}
+	})
+
+	t.Run("fingerprint_ca", func(t *testing.T) {
+		out, err := runCertArgs(t, []string{"cert", "fingerprint", "--which", "ca"})
+		if err != nil {
+			t.Fatalf("fingerprint ca: %v\n%s", err, out)
+		}
+		fp := strings.TrimSpace(out)
+		if len(fp) != 64 || !isHex(fp) {
+			t.Errorf("ca fingerprint = %q, want 64 hex chars", fp)
+		}
+	})
+
+	t.Run("fingerprint_server", func(t *testing.T) {
+		out, err := runCertArgs(t, []string{"cert", "fingerprint", "--which", "server"})
+		if err != nil {
+			t.Fatalf("fingerprint server: %v\n%s", err, out)
+		}
+		fp := strings.TrimSpace(out)
+		if len(fp) != 64 || !isHex(fp) {
+			t.Errorf("server fingerprint = %q, want 64 hex chars", fp)
+		}
+	})
+
+	t.Run("renew", func(t *testing.T) {
+		out, err := runCertArgs(t, []string{"cert", "renew"})
+		if err != nil {
+			t.Fatalf("renew: %v\n%s", err, out)
+		}
+		if !strings.Contains(out, "rotated") {
+			t.Errorf("renew output unexpected: %s", out)
+		}
+	})
+
+	t.Run("file_modes", func(t *testing.T) {
+		dir := os.Getenv("ORCA_HOME")
+		checks := []struct {
+			path string
+			want os.FileMode
+		}{
+			{"ca.crt", 0o644},
+			{"ca.key", 0o600},
+			{"server.crt", 0o644},
+			{"server.key", 0o600},
+		}
+		for _, c := range checks {
+			info, err := os.Stat(filepath.Join(dir, c.path))
+			if err != nil {
+				t.Fatalf("stat %s: %v", c.path, err)
+			}
+			if got := info.Mode().Perm(); got != c.want {
+				t.Errorf("mode %s = %04o, want %04o (REQ-033)", c.path, got, c.want)
+			}
+		}
+	})
+}
+
+func isHex(s string) bool {
+	for _, r := range s {
+		if !((r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') || (r >= 'A' && r <= 'F')) {
+			return false
+		}
+	}
+	return true
+}

internal/cli/cert_test.go

@@ -0,0 +1,37 @@
+package cli
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCertCommandRegistered(t *testing.T) {
+	found := false
+	for _, cmd := range rootCmd.Commands() {
+		if strings.Fields(cmd.Use)[0] == "cert" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatal("cert command not registered on rootCmd")
+	}
+}
+
+func TestCertSubcommands(t *testing.T) {
+	expected := []string{"ca-init", "gen", "show", "renew", "fingerprint"}
+	registered := make(map[string]bool)
+	for _, cmd := range rootCmd.Commands() {
+		if strings.Fields(cmd.Use)[0] != "cert" {
+			continue
+		}
+		for _, sub := range cmd.Commands() {
+			registered[strings.Fields(sub.Use)[0]] = true
+		}
+	}
+	for _, name := range expected {
+		if !registered[name] {
+			t.Errorf("expected cert subcommand %q not registered", name)
+		}
+	}
+}

internal/cli/daemon.go

@@ -34,10 +34,14 @@ var daemonCmd = &cobra.Command{
 		defer closer()
 
 		log := newLogger()
+		addr := daemonAddr
+		if cfg := configFromCtx(cmd.Context()); cfg != nil && cfg.ListenAddr != "" && addr == ":8080" {
+			addr = cfg.ListenAddr
+		}
 		srv := daemon.NewServer(daemon.Options{
 			DB:    db,
 			Log:   log,
-			Addr:  daemonAddr,
+			Addr:  addr,
 			Actor: "daemon",
 		})
 

internal/cli/doctor.go

@@ -69,7 +69,35 @@ var doctorDBCmd = &cobra.Command{
 	},
 }
 
+var doctorOSCmd = &cobra.Command{
+	Use:   "os",
+	Short: "Run the OS detection self-check (v0.6 P03)",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		c := doctor.OS()
+		r, msg := c.Run(cmd.Context())
+		if jsonOutput {
+			return printJSON(doctor.CheckResult{Name: c.Name, Result: r, Message: msg})
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "%-20s %-5s  %s\n", c.Name, r, msg)
+		return nil
+	},
+}
+
+var doctorProxmoxCmd = &cobra.Command{
+	Use:   "proxmox",
+	Short: "Run the proxmox node reachability self-check (v0.6 P03)",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		c := doctor.Proxmox()
+		r, msg := c.Run(cmd.Context())
+		if jsonOutput {
+			return printJSON(doctor.CheckResult{Name: c.Name, Result: r, Message: msg})
+		}
+		fmt.Fprintf(cmd.OutOrStdout(), "%-20s %-5s  %s\n", c.Name, r, msg)
+		return nil
+	},
+}
+
 func init() {
-	doctorCmd.AddCommand(doctorCertCmd, doctorNetworkCmd, doctorDBCmd)
+	doctorCmd.AddCommand(doctorCertCmd, doctorNetworkCmd, doctorDBCmd, doctorOSCmd, doctorProxmoxCmd)
 	rootCmd.AddCommand(doctorCmd)
 }

internal/cli/init.go

@@ -1,35 +1,194 @@
 package cli
 
 import (
+	"context"
 	"fmt"
 	"os"
+	"time"
 
+	"github.com/google/uuid"
 	"github.com/spf13/cobra"
 
 	"git.cloudinit.dev/coreci/orca/internal/certpaths"
+	"git.cloudinit.dev/coreci/orca/internal/model"
+	"git.cloudinit.dev/coreci/orca/internal/security"
+	"git.cloudinit.dev/coreci/orca/internal/store"
+)
+
+const (
+	initCAN       = "orca-internal-ca"
+	localhostName = "localhost"
+	localhostAddr = "localhost:8443"
 )
 
 var initCmd = &cobra.Command{
 	Use:   "init",
-	Short: "Initialize local orca state directory",
-	Long:  "Create the local orca state directory (honors $ORCA_HOME; defaults to ~/.orca) and write a default config file.",
+	Short: "Initialize local orca state with full bootstrap",
+	Long: `Initialize the local orca state directory and provision all
+dependencies required for ` + "`orca doctor`" + ` to pass:
+
+  1. Create the namespace directory (honors $ORCA_HOME; defaults to ~/.orca)
+  2. Open and migrate the SQLite database (migrations 0001..0006)
+  3. Bootstrap the internal CA (ca.crt + ca.key) if not already present
+  4. Generate the server cert (server.crt + server.key) if not already present
+  5. Auto-detect the local OS via /etc/os-release
+  6. Register a localhost node (kind=localhost, os=<detected>)
+
+Idempotent: re-running is safe and will refresh last_seen + os on the
+localhost node without regenerating certs or changing the node ID.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		orcaDir := certpaths.Dir()
-		if err := os.MkdirAll(orcaDir, 0o755); err != nil {
-			return fmt.Errorf("create orca dir: %w", err)
-		}
-		result := map[string]string{
-			"path":   orcaDir,
-			"status": "initialized",
-		}
-		if jsonOutput {
-			return printJSON(result)
-		}
-		printText("✓ Initialized orca state at %s\n", orcaDir)
-		return nil
+		return runInit(cmd.OutOrStdout())
 	},
 }
 
+func runInit(out interface{ Write([]byte) (int, error) }) error {
+	dir := certpaths.Dir()
+
+	type stepResult struct {
+		Label  string `json:"label"`
+		Status string `json:"status"`
+		Detail string `json:"detail,omitempty"`
+	}
+	type initSummary struct {
+		Namespace       string       `json:"namespace"`
+		Database        string       `json:"database"`
+		CAFingerprint   string       `json:"ca_fingerprint,omitempty"`
+		CertFingerprint string       `json:"cert_fingerprint,omitempty"`
+		OS              string       `json:"os"`
+		NodeID          string       `json:"node_id"`
+		NodeName        string       `json:"node_name"`
+		Steps           []stepResult `json:"steps"`
+	}
+	summary := initSummary{Namespace: dir}
+
+	// Step 1: namespace dir.
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return fmt.Errorf("create orca dir: %w", err)
+	}
+	summary.Steps = append(summary.Steps, stepResult{Label: "namespace", Status: "ok", Detail: dir})
+	if !jsonOutput {
+		fmt.Fprintf(out, "✓ Namespace dir: %s\n", dir)
+	}
+
+	// Step 2: database + migrations.
+	dbPath := certpaths.DBPath()
+	db, err := store.Open(dbPath)
+	if err != nil {
+		return fmt.Errorf("open database: %w", err)
+	}
+	defer db.Close()
+	summary.Database = dbPath
+	summary.Steps = append(summary.Steps, stepResult{Label: "database", Status: "ok", Detail: dbPath})
+	if !jsonOutput {
+		fmt.Fprintf(out, "✓ Database initialized: %s\n", dbPath)
+	}
+
+	// Step 3: CA bootstrap (idempotent — CAInit has a fast-path).
+	ca, err := security.CAInit(dir, initCAN)
+	if err != nil {
+		return fmt.Errorf("bootstrap CA: %w", err)
+	}
+	caFp := ca.Fingerprint()
+	summary.CAFingerprint = caFp
+	summary.Steps = append(summary.Steps, stepResult{Label: "ca", Status: "ok", Detail: caFp[:16] + "..."})
+	if !jsonOutput {
+		fmt.Fprintf(out, "✓ CA provisioned: fp=%s\n", caFp[:16]+"...")
+	}
+
+	// Step 4: server cert (only if absent — D-036 idempotency).
+	certPath := certpaths.ServerCertPath()
+	certFp := ""
+	if _, err := os.Stat(certPath); err == nil {
+		// Already exists — load fingerprint for the summary.
+		if fp, err := security.Fingerprint(certPath); err == nil {
+			certFp = fp
+		}
+		summary.Steps = append(summary.Steps, stepResult{Label: "server-cert", Status: "skipped", Detail: "already present"})
+	} else if os.IsNotExist(err) {
+		keyPEM, csrPEM, err := security.GenerateCSR("localhost", []string{"localhost", "127.0.0.1"})
+		if err != nil {
+			return fmt.Errorf("generate server CSR: %w", err)
+		}
+		certPEM, err := ca.SignCSR(csrPEM)
+		if err != nil {
+			return fmt.Errorf("sign server CSR: %w", err)
+		}
+		if err := security.WriteCert(certPath, certPEM); err != nil {
+			return fmt.Errorf("write server cert: %w", err)
+		}
+		if err := security.WriteKey(certpaths.ServerKeyPath(), keyPEM); err != nil {
+			return fmt.Errorf("write server key: %w", err)
+		}
+		certFp = security.FingerprintOf(parseFirstCertDER(certPEM))
+		summary.Steps = append(summary.Steps, stepResult{Label: "server-cert", Status: "ok", Detail: certFp[:16] + "..."})
+	} else {
+		return fmt.Errorf("stat server cert: %w", err)
+	}
+	summary.CertFingerprint = certFp
+	if !jsonOutput {
+		if certFp != "" {
+			fmt.Fprintf(out, "✓ Server cert provisioned: fp=%s\n", certFp[:16]+"...")
+		} else {
+			fmt.Fprintf(out, "✓ Server cert: already present\n")
+		}
+	}
+
+	// Step 5: OS detection.
+	osDetected := detectOS()
+	summary.OS = osDetected
+	summary.Steps = append(summary.Steps, stepResult{Label: "os", Status: "ok", Detail: osDetected})
+	if !jsonOutput {
+		fmt.Fprintf(out, "✓ OS detected: %s\n", osDetected)
+	}
+
+	// Step 6: localhost node upsert (idempotent per D-036).
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	repo := store.NewNodeRepo(db)
+	existing, err := repo.GetByName(ctx, localhostName)
+	if err == nil {
+		// Refresh last_seen + os; keep id and joined_at.
+		if err := repo.UpdateLastSeenAndOS(ctx, existing.ID, osDetected); err != nil {
+			return fmt.Errorf("refresh localhost node: %w", err)
+		}
+		summary.NodeID = existing.ID
+		summary.NodeName = existing.Name
+		summary.Steps = append(summary.Steps, stepResult{Label: "localhost-node", Status: "refreshed", Detail: existing.ID})
+		if !jsonOutput {
+			fmt.Fprintf(out, "✓ Localhost node refreshed: %s (os=%s)\n", existing.ID, osDetected)
+		}
+	} else if err == store.ErrNotFound {
+		node := &model.Node{
+			ID:       uuid.NewString(),
+			Name:     localhostName,
+			Address:  localhostAddr,
+			State:    model.NodeStateReady,
+			JoinedAt: time.Now().UTC(),
+			LastSeen: time.Now().UTC(),
+			Kind:     string(model.NodeKindLocalhost),
+			OS:       osDetected,
+		}
+		if err := repo.Insert(ctx, node); err != nil {
+			return fmt.Errorf("insert localhost node: %w", err)
+		}
+		summary.NodeID = node.ID
+		summary.NodeName = node.Name
+		summary.Steps = append(summary.Steps, stepResult{Label: "localhost-node", Status: "ok", Detail: node.ID})
+		if !jsonOutput {
+			fmt.Fprintf(out, "✓ Localhost node registered: %s (os=%s)\n", node.ID, osDetected)
+		}
+	} else {
+		return fmt.Errorf("lookup localhost node: %w", err)
+	}
+
+	if jsonOutput {
+		return printJSON(summary)
+	}
+	fmt.Fprintf(out, "\n✓ orca init complete — run `orca doctor` to verify.\n")
+	return nil
+}
+
 func init() {
 	rootCmd.AddCommand(initCmd)
 }

internal/cli/init_test.go

@@ -0,0 +1,205 @@
+package cli
+
+import (
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"git.cloudinit.dev/coreci/orca/internal/certpaths"
+	"git.cloudinit.dev/coreci/orca/internal/model"
+	"git.cloudinit.dev/coreci/orca/internal/store"
+)
+
+// initTestEnv sets ORCA_HOME to a temp dir and returns a cleanup func.
+func initTestEnv(t *testing.T) (string, func()) {
+	t.Helper()
+	dir := t.TempDir()
+	orig := os.Getenv("ORCA_HOME")
+	if err := os.Setenv("ORCA_HOME", dir); err != nil {
+		t.Fatalf("set ORCA_HOME: %v", err)
+	}
+	return dir, func() {
+		if err := os.Setenv("ORCA_HOME", orig); err != nil {
+			t.Fatalf("restore ORCA_HOME: %v", err)
+		}
+	}
+}
+
+// discardWriter is an io.Writer that discards all output (for tests
+// that don't need to inspect init stdout).
+type discardWriter struct{}
+
+func (discardWriter) Write(p []byte) (int, error) { return len(p), nil }
+
+var _ io.Writer = discardWriter{}
+
+func TestInit_FullBootstrap(t *testing.T) {
+	dir, cleanup := initTestEnv(t)
+	defer cleanup()
+
+	if err := runInit(discardWriter{}); err != nil {
+		t.Fatalf("init: %v", err)
+	}
+
+	// Verify namespace dir exists.
+	if _, err := os.Stat(dir); err != nil {
+		t.Errorf("namespace dir missing: %v", err)
+	}
+
+	// Verify CA files exist with correct modes.
+	caCert := certpaths.CACertPath()
+	caKey := certpaths.CAKeyPath()
+	if _, err := os.Stat(caCert); err != nil {
+		t.Errorf("ca.crt missing: %v", err)
+	}
+	if info, err := os.Stat(caKey); err == nil {
+		if info.Mode().Perm() != 0o600 {
+			t.Errorf("ca.key mode = %04o, want 0600", info.Mode().Perm())
+		}
+	} else {
+		t.Errorf("ca.key missing: %v", err)
+	}
+
+	// Verify server cert exists.
+	if _, err := os.Stat(certpaths.ServerCertPath()); err != nil {
+		t.Errorf("server.crt missing: %v", err)
+	}
+
+	// Verify DB exists and has migrations applied.
+	db, err := store.Open(certpaths.DBPath())
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	defer db.Close()
+
+	ctx := context.Background()
+	version, err := store.MigrationVersion(ctx, db)
+	if err != nil {
+		t.Fatalf("migration version: %v", err)
+	}
+	if version != "0007_certs_serial_unique.sql" {
+		t.Errorf("migration version = %q, want 0007_certs_serial_unique.sql", version)
+	}
+
+	// Verify localhost node registered with kind=localhost.
+	repo := store.NewNodeRepo(db)
+	node, err := repo.GetByName(ctx, "localhost")
+	if err != nil {
+		t.Fatalf("get localhost node: %v", err)
+	}
+	if node.Kind != string(model.NodeKindLocalhost) {
+		t.Errorf("node kind = %q, want localhost", node.Kind)
+	}
+	if node.OS == "" {
+		t.Errorf("node os is empty, expected detected value")
+	}
+	if node.Address != "localhost:8443" {
+		t.Errorf("node address = %q, want localhost:8443", node.Address)
+	}
+}
+
+func TestInit_IdempotentReRun(t *testing.T) {
+	_, cleanup := initTestEnv(t)
+	defer cleanup()
+
+	// First init.
+	if err := runInit(discardWriter{}); err != nil {
+		t.Fatalf("first init: %v", err)
+	}
+
+	// Capture first-run state.
+	caCertBefore, _ := os.ReadFile(certpaths.CACertPath())
+	serverCertBefore, _ := os.ReadFile(certpaths.ServerCertPath())
+
+	db, err := store.Open(certpaths.DBPath())
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	repo := store.NewNodeRepo(db)
+	ctx := context.Background()
+	nodeBefore, err := repo.GetByName(ctx, "localhost")
+	if err != nil {
+		t.Fatalf("get node before: %v", err)
+	}
+	nodeIDBefore := nodeBefore.ID
+	joinedAtBefore := nodeBefore.JoinedAt
+	if err := db.Close(); err != nil {
+		t.Fatalf("close db: %v", err)
+	}
+
+	// Wait a moment so last_seen can differ.
+	time.Sleep(50 * time.Millisecond)
+
+	// Second init (should be idempotent).
+	if err := runInit(discardWriter{}); err != nil {
+		t.Fatalf("second init: %v", err)
+	}
+
+	// CA and server cert must NOT have been regenerated.
+	caCertAfter, _ := os.ReadFile(certpaths.CACertPath())
+	serverCertAfter, _ := os.ReadFile(certpaths.ServerCertPath())
+	if string(caCertBefore) != string(caCertAfter) {
+		t.Error("CA was regenerated on re-run (D-036 violation)")
+	}
+	if string(serverCertBefore) != string(serverCertAfter) {
+		t.Error("server cert was regenerated on re-run (D-036 violation)")
+	}
+
+	// Node ID and joined_at must be unchanged; last_seen should be refreshed.
+	db, err = store.Open(certpaths.DBPath())
+	if err != nil {
+		t.Fatalf("reopen db: %v", err)
+	}
+	defer db.Close()
+	repo = store.NewNodeRepo(db)
+	nodeAfter, err := repo.GetByName(ctx, "localhost")
+	if err != nil {
+		t.Fatalf("get node after: %v", err)
+	}
+	if nodeAfter.ID != nodeIDBefore {
+		t.Errorf("node id changed: was %s, now %s (D-036 violation)", nodeIDBefore, nodeAfter.ID)
+	}
+	if !nodeAfter.JoinedAt.Equal(joinedAtBefore) {
+		t.Errorf("joined_at changed: was %v, now %v (D-036 violation)", joinedAtBefore, nodeAfter.JoinedAt)
+	}
+	if !nodeAfter.LastSeen.After(joinedAtBefore) {
+		t.Errorf("last_seen not refreshed: was %v, now %v", joinedAtBefore, nodeAfter.LastSeen)
+	}
+
+	// No duplicate localhost nodes.
+	nodes, err := repo.List(ctx)
+	if err != nil {
+		t.Fatalf("list nodes: %v", err)
+	}
+	localhostCount := 0
+	for _, n := range nodes {
+		if n.Name == "localhost" {
+			localhostCount++
+		}
+	}
+	if localhostCount != 1 {
+		t.Errorf("found %d localhost nodes, want 1 (idempotency)", localhostCount)
+	}
+}
+
+func TestInit_NamespaceDirCreation(t *testing.T) {
+	dir, cleanup := initTestEnv(t)
+	defer cleanup()
+
+	// The namespace dir is the ORCA_HOME temp dir itself — but let's
+	// point at a non-existent subdir to test MkdirAll.
+	subDir := filepath.Join(dir, "nested", "orca-state")
+	if err := os.Setenv("ORCA_HOME", subDir); err != nil {
+		t.Fatalf("set ORCA_HOME: %v", err)
+	}
+
+	if err := runInit(discardWriter{}); err != nil {
+		t.Fatalf("init with nested dir: %v", err)
+	}
+	if _, err := os.Stat(subDir); err != nil {
+		t.Errorf("nested namespace dir not created: %v", err)
+	}
+}

internal/cli/namespace_test.go

@@ -98,15 +98,23 @@ func TestInitJSONOutput(t *testing.T) {
 		t.Fatalf("init --json: %v", err)
 	}
 
-	var result map[string]string
+	// v0.6: init --json now outputs a full bootstrap summary object.
+	var result map[string]any
 	if err := json.Unmarshal(bytes.TrimSpace(buf.Bytes()), &result); err != nil {
 		t.Fatalf("unmarshal init output: %v\noutput: %s", err, buf.String())
 	}
-	if result["path"] != tmp {
-		t.Errorf("init --json path = %q, want %q", result["path"], tmp)
+	if result["namespace"] != tmp {
+		t.Errorf("init --json namespace = %q, want %q", result["namespace"], tmp)
 	}
-	if result["status"] != "initialized" {
-		t.Errorf("init --json status = %q, want %q", result["status"], "initialized")
+	if result["os"] == nil || result["os"] == "" {
+		t.Errorf("init --json os is missing/empty")
+	}
+	if result["node_id"] == nil || result["node_id"] == "" {
+		t.Errorf("init --json node_id is missing/empty")
+	}
+	steps, ok := result["steps"].([]any)
+	if !ok || len(steps) < 6 {
+		t.Errorf("init --json steps: expected 6+ entries, got %v", result["steps"])
 	}
 }
 

internal/cli/node.go

@@ -17,6 +17,7 @@ import (
 	"git.cloudinit.dev/coreci/orca/internal/certpaths"
 	"git.cloudinit.dev/coreci/orca/internal/engine"
 	"git.cloudinit.dev/coreci/orca/internal/model"
+	"git.cloudinit.dev/coreci/orca/internal/proxmox"
 	"git.cloudinit.dev/coreci/orca/internal/security"
 	"git.cloudinit.dev/coreci/orca/internal/store"
 )
@@ -47,6 +48,13 @@ var (
 	joinName     string
 	joinAddr     string
 	joinCAFinger string
+	joinType     string
+	joinHost     string
+	joinSSHUser  string
+	joinPassword string
+	joinSSHPort  int
+	proxmoxUser  string
+	proxmoxRole  string
 	leaveID      string
 	nodeWatch    bool
 )
@@ -60,60 +68,143 @@ var nodeCmd = &cobra.Command{
 var nodeJoinCmd = &cobra.Command{
 	Use:   "join",
 	Short: "Join a node to the orca registry",
-	Long:  "Register a node in the local orca registry. Persisted to SQLite.",
+	Long: `Register a node in the local orca registry. Persisted to SQLite.
+
+Node types (via --type):
+  localhost (default): register a local or Linux node (existing behavior)
+  proxmox:             SSH-bootstrap a remote Proxmox VE 8/9 host
+                       (deploys orca pubkey, creates orca user + PVE role +
+                       sudoers allowlist; requires --host + --password)`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if joinName == "" {
-			return fmt.Errorf("--name is required")
+		if joinType == "proxmox" {
+			return joinProxmox(cmd)
 		}
-		if joinAddr == "" {
-			joinAddr = "localhost:8443"
-		}
-
-		// REQ-026: if --ca-fingerprint is set, verify the on-disk CA
-		// matches the pinned value before we touch the registry. This
-		// prevents typos in the operator-supplied fingerprint from
-		// silently degrading to "no pin" and accepting any cert.
-		if joinCAFinger != "" {
-			fp, err := security.Fingerprint(certpaths.CACertPath())
-			if err != nil {
-				return fmt.Errorf("--ca-fingerprint set but local CA is missing: %w (run `orca cert ca-init` first)", err)
-			}
-			if fp != joinCAFinger {
-				return fmt.Errorf(
-					"CA fingerprint mismatch: on-disk=%s, pinned=%s — refusing to join (REQ-026)",
-					fp, joinCAFinger,
-				)
-			}
-		}
-
-		ctx, cancel := context.WithTimeout(cmd.Context(), 5*time.Second)
-		defer cancel()
-
-		registry, closer, err := nodeRegistry()
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		node := &model.Node{
-			ID:       uuid.NewString(),
-			Name:     joinName,
-			Address:  joinAddr,
-			State:    model.NodeStateReady,
-			JoinedAt: time.Now().UTC(),
-			LastSeen: time.Now().UTC(),
-		}
-		if err := registry.Join(ctx, node); err != nil {
-			return err
-		}
-		if jsonOutput {
-			return printJSON(node)
-		}
-		fmt.Fprintf(cmd.OutOrStdout(), "✓ Node joined: %s (%s) at %s\n", node.ID, node.Name, node.Address)
-		return nil
+		return joinLocal(cmd)
 	},
 }
 
+// joinLocal is the existing localhost/Linux node join flow (fingerprint
+// check + registry.Insert).
+func joinLocal(cmd *cobra.Command) error {
+	if joinName == "" {
+		return fmt.Errorf("--name is required")
+	}
+	if joinAddr == "" {
+		joinAddr = "localhost:8443"
+	}
+
+	// REQ-026: if --ca-fingerprint is set, verify the on-disk CA
+	// matches the pinned value before we touch the registry. This
+	// prevents typos in the operator-supplied fingerprint from
+	// silently degrading to "no pin" and accepting any cert.
+	if joinCAFinger != "" {
+		fp, err := security.Fingerprint(certpaths.CACertPath())
+		if err != nil {
+			return fmt.Errorf("--ca-fingerprint set but local CA is missing: %w (run `orca cert ca-init` first)", err)
+		}
+		if fp != joinCAFinger {
+			return fmt.Errorf(
+				"CA fingerprint mismatch: on-disk=%s, pinned=%s — refusing to join (REQ-026)",
+				fp, joinCAFinger,
+			)
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(cmd.Context(), 5*time.Second)
+	defer cancel()
+
+	registry, closer, err := nodeRegistry()
+	if err != nil {
+		return err
+	}
+	defer closer()
+
+	node := &model.Node{
+		ID:       uuid.NewString(),
+		Name:     joinName,
+		Address:  joinAddr,
+		State:    model.NodeStateReady,
+		JoinedAt: time.Now().UTC(),
+		LastSeen: time.Now().UTC(),
+	}
+	if err := registry.Join(ctx, node); err != nil {
+		return err
+	}
+	if jsonOutput {
+		return printJSON(node)
+	}
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Node joined: %s (%s) at %s\n", node.ID, node.Name, node.Address)
+	return nil
+}
+
+// joinProxmox bootstraps a remote Proxmox VE 8/9 host via SSH and
+// registers it as an orca node (REQ-050, REQ-051). The password is
+// never persisted (D-031).
+func joinProxmox(cmd *cobra.Command) error {
+	if joinHost == "" {
+		return fmt.Errorf("--host is required for --type proxmox")
+	}
+	password := joinPassword
+	if password == "" {
+		password = os.Getenv("ORCA_PROXMOX_PASSWORD")
+	}
+	if password == "" {
+		return fmt.Errorf("password is required for --type proxmox (use --password or $ORCA_PROXMOX_PASSWORD)")
+	}
+
+	ctx, cancel := context.WithTimeout(cmd.Context(), 60*time.Second)
+	defer cancel()
+
+	result, err := proxmox.BootstrapProxmox(ctx, proxmox.Options{
+		Host:        joinHost,
+		SSHUser:     joinSSHUser,
+		Password:    password,
+		ProxmoxUser: proxmoxUser,
+		ProxmoxRole: proxmoxRole,
+		SSHPort:     joinSSHPort,
+		Logger:      newLogger(),
+	})
+	if err != nil {
+		return fmt.Errorf("proxmox bootstrap: %w", err)
+	}
+
+	// Zero the password byte slice (D-031 — never persist, minimize memory exposure).
+	pwBytes := []byte(password)
+	for i := range pwBytes {
+		pwBytes[i] = 0
+	}
+
+	// Register the proxmox node in the orca registry.
+	registry, closer, err := nodeRegistry()
+	if err != nil {
+		return err
+	}
+	defer closer()
+
+	regCtx, regCancel := context.WithTimeout(ctx, 5*time.Second)
+	defer regCancel()
+
+	node := &model.Node{
+		ID:       uuid.NewString(),
+		Name:     result.NodeName,
+		Address:  result.NodeAddress,
+		State:    model.NodeStateReady,
+		JoinedAt: time.Now().UTC(),
+		LastSeen: time.Now().UTC(),
+		Kind:     string(model.NodeKindProxmox),
+		OS:       "pve",
+	}
+	if err := registry.Join(regCtx, node); err != nil {
+		return fmt.Errorf("register proxmox node: %w", err)
+	}
+	if jsonOutput {
+		return printJSON(node)
+	}
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Proxmox node joined: %s (%s) at %s\n", node.ID, node.Name, node.Address)
+	fmt.Fprintf(cmd.OutOrStdout(), "  role: %s, user: %s@pam\n", proxmoxRole, proxmoxUser)
+	return nil
+}
+
 var nodeLeaveCmd = &cobra.Command{
 	Use:   "leave [node-id]",
 	Short: "Remove a node from the orca registry",
@@ -251,9 +342,16 @@ func renderNodeTable(nodes []*model.Node) string {
 }
 
 func init() {
-	nodeJoinCmd.Flags().StringVar(&joinName, "name", "", "node name (required)")
+	nodeJoinCmd.Flags().StringVar(&joinName, "name", "", "node name (required for --type localhost)")
 	nodeJoinCmd.Flags().StringVar(&joinAddr, "addr", "", "node address (default localhost:8443)")
 	nodeJoinCmd.Flags().StringVar(&joinCAFinger, "ca-fingerprint", "", "pin CA cert SHA-256 (REQ-026); fails if on-disk CA doesn't match")
+	nodeJoinCmd.Flags().StringVar(&joinType, "type", "localhost", "node type: localhost (default) or proxmox (SSH bootstrap)")
+	nodeJoinCmd.Flags().StringVar(&joinHost, "host", "", "proxmox host address (IP/hostname, no port; required for --type proxmox)")
+	nodeJoinCmd.Flags().StringVar(&joinSSHUser, "ssh-user", "root", "SSH username for proxmox bootstrap (default root)")
+	nodeJoinCmd.Flags().StringVar(&joinPassword, "password", "", "SSH password for proxmox bootstrap (never persisted; prefer $ORCA_PROXMOX_PASSWORD)")
+	nodeJoinCmd.Flags().IntVar(&joinSSHPort, "ssh-port", 22, "SSH port for proxmox bootstrap (default 22)")
+	nodeJoinCmd.Flags().StringVar(&proxmoxUser, "proxmox-user", "orca", "Linux system user to create on the proxmox host (config-overridable)")
+	nodeJoinCmd.Flags().StringVar(&proxmoxRole, "proxmox-role", "OrcaOperator", "PVE custom role to create (config-overridable)")
 	nodeLeaveCmd.Flags().StringVar(&leaveID, "id", "", "node id")
 	nodeListCmd.Flags().BoolVar(&nodeWatch, "watch", false, "stream nodes until Ctrl-C (table refresh or --json per-event)")
 

internal/cli/osdetect.go

@@ -0,0 +1,10 @@
+package cli
+
+import "git.cloudinit.dev/coreci/orca/internal/osdetect"
+
+// detectOS reads /etc/os-release and returns the ID= value.
+// Delegates to internal/osdetect to avoid import cycles with
+// internal/doctor (both need OS detection).
+func detectOS() string {
+	return osdetect.Detect()
+}

internal/cli/osdetect_test.go

@@ -0,0 +1,19 @@
+package cli
+
+import (
+	"testing"
+)
+
+// The osdetect parsing/detection logic is tested in
+// internal/osdetect/osdetect_test.go. These tests verify the cli
+// wrapper delegates correctly.
+
+func TestDetectOS_DelegatesToPackage(t *testing.T) {
+	// On this host (Ubuntu), detectOS should return "ubuntu" via the
+	// osdetect package. If /etc/os-release is absent (e.g., in a
+	// minimal container), it returns "linux".
+	result := detectOS()
+	if result == "" {
+		t.Error("detectOS returned empty string, expected a non-empty OS ID")
+	}
+}

internal/cli/root.go

@@ -1,13 +1,18 @@
 package cli
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
 
 	"github.com/spf13/cobra"
+
+	"git.cloudinit.dev/coreci/orca/internal/config"
 )
 
+type configCtxKey struct{}
+
 var (
 	version   = "0.1.0-dev"
 	gitCommit = "unknown"
@@ -33,6 +38,13 @@ over feature richness.`,
 				return fmt.Errorf("set ORCA_HOME for --system: %w", err)
 			}
 		}
+		if configPath != "" {
+			cfg, err := config.Load(configPath)
+			if err != nil {
+				return fmt.Errorf("load config %s: %w", configPath, err)
+			}
+			cmd.SetContext(context.WithValue(cmd.Context(), configCtxKey{}, cfg))
+		}
 		return nil
 	},
 }
@@ -40,11 +52,20 @@ over feature richness.`,
 var (
 	jsonOutput      bool
 	systemNamespace bool
+	configPath      string
 )
 
 func init() {
 	rootCmd.PersistentFlags().BoolVar(&jsonOutput, "json", false, "output in JSON format")
 	rootCmd.PersistentFlags().BoolVar(&systemNamespace, "system", false, "use system-level namespace root (/root/.orca) instead of user-level (~/.orca)")
+	rootCmd.PersistentFlags().StringVar(&configPath, "config", "", "path to config.hcl (overrides ~/.orca/config.hcl)")
+}
+
+func configFromCtx(ctx context.Context) *config.Config {
+	if v, ok := ctx.Value(configCtxKey{}).(*config.Config); ok {
+		return v
+	}
+	return nil
 }
 
 func Execute() error {

internal/cli/root_test.go

@@ -1,8 +1,11 @@
 package cli
 
 import (
+	"os"
 	"strings"
 	"testing"
+
+	"git.cloudinit.dev/coreci/orca/internal/config"
 )
 
 func TestVersionCommandExists(t *testing.T) {
@@ -65,3 +68,47 @@ func TestRootHelpMentionsKeyPillars(t *testing.T) {
 		}
 	}
 }
+
+func TestConfigFlagRegistered(t *testing.T) {
+	f := rootCmd.PersistentFlags().Lookup("config")
+	if f == nil {
+		t.Fatal("--config persistent flag not registered")
+	}
+	if f.DefValue != "" {
+		t.Errorf("--config default = %q, want empty", f.DefValue)
+	}
+}
+
+func TestConfigFlagLoadsFile(t *testing.T) {
+	dir := t.TempDir()
+	cfgPath := dir + "/config.hcl"
+	cfgContent := `db_path          = "` + dir + `/test.db"
+listen_addr      = "127.0.0.1:9999"
+ca_path          = "` + dir + `/ca.crt"
+server_cert_path = "` + dir + `/server.crt"
+server_key_path  = "` + dir + `/server.key"
+
+node_capacity {
+  cpu       = 4
+  memory_mb = 8192
+}
+`
+	if err := os.WriteFile(cfgPath, []byte(cfgContent), 0o644); err != nil {
+		t.Fatalf("write config: %v", err)
+	}
+
+	old := configPath
+	configPath = cfgPath
+	defer func() { configPath = old }()
+
+	cfg, err := config.Load(cfgPath)
+	if err != nil {
+		t.Fatalf("load config: %v", err)
+	}
+	if cfg.ListenAddr != "127.0.0.1:9999" {
+		t.Errorf("listen_addr = %q, want 127.0.0.1:9999", cfg.ListenAddr)
+	}
+	if cfg.NodeCapacity == nil || cfg.NodeCapacity.CPU != 4 {
+		t.Errorf("node_capacity.cpu not parsed, got %+v", cfg.NodeCapacity)
+	}
+}

internal/config/config.go

@@ -0,0 +1,127 @@
+package config
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/hashicorp/hcl/v2/hclsimple"
+)
+
+type CapacityConfig struct {
+	CPU      int `hcl:"cpu,optional"`
+	MemoryMB int `hcl:"memory_mb,optional"`
+}
+
+type Config struct {
+	DBPath         string          `hcl:"db_path,optional"`
+	ListenAddr     string          `hcl:"listen_addr,optional"`
+	CAPath         string          `hcl:"ca_path,optional"`
+	ServerCertPath string          `hcl:"server_cert_path,optional"`
+	ServerKeyPath  string          `hcl:"server_key_path,optional"`
+	NodeCapacity   *CapacityConfig `hcl:"node_capacity,block"`
+}
+
+type Flags struct {
+	DBPath         *string
+	ListenAddr     *string
+	CAPath         *string
+	ServerCertPath *string
+	ServerKeyPath  *string
+	CPU            *int
+	MemoryMB       *int
+}
+
+type Environ map[string]string
+
+func Load(paths ...string) (*Config, error) {
+	for _, p := range paths {
+		if _, err := os.Stat(p); err != nil {
+			continue
+		}
+		data, err := os.ReadFile(p)
+		if err != nil {
+			return nil, fmt.Errorf("read config %s: %w", p, err)
+		}
+		var cfg Config
+		if err := hclsimple.Decode(p, data, nil, &cfg); err != nil {
+			return nil, fmt.Errorf("decode config %s: %w", p, err)
+		}
+		return &cfg, nil
+	}
+	return &Config{}, nil
+}
+
+func (c *Config) MergeOverrides(flags Flags, env Environ) *Config {
+	out := &Config{
+		DBPath:         c.DBPath,
+		ListenAddr:     c.ListenAddr,
+		CAPath:         c.CAPath,
+		ServerCertPath: c.ServerCertPath,
+		ServerKeyPath:  c.ServerKeyPath,
+		NodeCapacity:   c.NodeCapacity,
+	}
+
+	applyStr := func(flag *string, envKey, fileVal string) string {
+		if flag != nil {
+			return *flag
+		}
+		if v, ok := env[envKey]; ok && v != "" {
+			return v
+		}
+		return fileVal
+	}
+
+	out.DBPath = applyStr(flags.DBPath, "ORCA_DB", out.DBPath)
+	out.ListenAddr = applyStr(flags.ListenAddr, "ORCA_LISTEN_ADDR", out.ListenAddr)
+	out.CAPath = applyStr(flags.CAPath, "ORCA_CA_PATH", out.CAPath)
+	out.ServerCertPath = applyStr(flags.ServerCertPath, "ORCA_SERVER_CERT_PATH", out.ServerCertPath)
+	out.ServerKeyPath = applyStr(flags.ServerKeyPath, "ORCA_SERVER_KEY_PATH", out.ServerKeyPath)
+
+	if out.NodeCapacity == nil {
+		out.NodeCapacity = &CapacityConfig{}
+	} else {
+		nc := *out.NodeCapacity
+		out.NodeCapacity = &nc
+	}
+
+	if flags.CPU != nil {
+		out.NodeCapacity.CPU = *flags.CPU
+	} else if v, ok := env["ORCA_NODE_CPU"]; ok && v != "" {
+		if n, err := atoi(v); err == nil {
+			out.NodeCapacity.CPU = n
+		}
+	}
+
+	if flags.MemoryMB != nil {
+		out.NodeCapacity.MemoryMB = *flags.MemoryMB
+	} else if v, ok := env["ORCA_NODE_MEMORY_MB"]; ok && v != "" {
+		if n, err := atoi(v); err == nil {
+			out.NodeCapacity.MemoryMB = n
+		}
+	}
+
+	return out
+}
+
+func atoi(s string) (int, error) {
+	n := 0
+	if s == "" {
+		return 0, fmt.Errorf("empty")
+	}
+	neg := false
+	i := 0
+	if s[0] == '-' {
+		neg = true
+		i = 1
+	}
+	for ; i < len(s); i++ {
+		if s[i] < '0' || s[i] > '9' {
+			return 0, fmt.Errorf("bad")
+		}
+		n = n*10 + int(s[i]-'0')
+	}
+	if neg {
+		n = -n
+	}
+	return n, nil
+}

internal/config/config_test.go

@@ -0,0 +1,197 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+const exampleHCL = `
+db_path          = "/tmp/orca/test.db"
+listen_addr      = "127.0.0.1:9999"
+ca_path          = "/tmp/orca/ca.crt"
+server_cert_path = "/tmp/orca/server.crt"
+server_key_path  = "/tmp/orca/server.key"
+
+node_capacity {
+  cpu       = 4
+  memory_mb = 8192
+}
+`
+
+func writeFile(t *testing.T, dir, name, content string) string {
+	t.Helper()
+	p := filepath.Join(dir, name)
+	if err := os.WriteFile(p, []byte(content), 0644); err != nil {
+		t.Fatalf("write %s: %v", p, err)
+	}
+	return p
+}
+
+func TestLoad_Valid(t *testing.T) {
+	p := writeFile(t, t.TempDir(), "config.hcl", exampleHCL)
+	cfg, err := Load(p)
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.DBPath != "/tmp/orca/test.db" {
+		t.Errorf("DBPath=%q", cfg.DBPath)
+	}
+	if cfg.ListenAddr != "127.0.0.1:9999" {
+		t.Errorf("ListenAddr=%q", cfg.ListenAddr)
+	}
+	if cfg.CAPath != "/tmp/orca/ca.crt" {
+		t.Errorf("CAPath=%q", cfg.CAPath)
+	}
+	if cfg.ServerCertPath != "/tmp/orca/server.crt" {
+		t.Errorf("ServerCertPath=%q", cfg.ServerCertPath)
+	}
+	if cfg.ServerKeyPath != "/tmp/orca/server.key" {
+		t.Errorf("ServerKeyPath=%q", cfg.ServerKeyPath)
+	}
+	if cfg.NodeCapacity == nil {
+		t.Fatal("NodeCapacity nil")
+	}
+	if cfg.NodeCapacity.CPU != 4 {
+		t.Errorf("CPU=%d", cfg.NodeCapacity.CPU)
+	}
+	if cfg.NodeCapacity.MemoryMB != 8192 {
+		t.Errorf("MemoryMB=%d", cfg.NodeCapacity.MemoryMB)
+	}
+}
+
+func TestLoad_Missing(t *testing.T) {
+	cfg, err := Load(filepath.Join(t.TempDir(), "nope.hcl"))
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg == nil {
+		t.Fatal("nil config")
+	}
+	if cfg.DBPath != "" || cfg.ListenAddr != "" || cfg.NodeCapacity != nil {
+		t.Errorf("expected zero config, got %+v", cfg)
+	}
+}
+
+func TestLoad_Malformed(t *testing.T) {
+	p := writeFile(t, t.TempDir(), "bad.hcl", "db_path = ")
+	cfg, err := Load(p)
+	if err == nil {
+		t.Fatalf("expected error, got %+v", cfg)
+	}
+}
+
+func TestLoad_FirstExisting(t *testing.T) {
+	dir := t.TempDir()
+	existing := writeFile(t, dir, "real.hcl", exampleHCL)
+	missing := filepath.Join(dir, "missing.hcl")
+	cfg, err := Load(missing, existing)
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.DBPath != "/tmp/orca/test.db" {
+		t.Errorf("DBPath=%q", cfg.DBPath)
+	}
+}
+
+func strPtr(s string) *string { return &s }
+func intPtr(i int) *int       { return &i }
+
+func TestMergeOverrides_FlagWins(t *testing.T) {
+	cfg := &Config{
+		DBPath:     "/file.db",
+		ListenAddr: "127.0.0.1:9000",
+		NodeCapacity: &CapacityConfig{
+			CPU:      4,
+			MemoryMB: 8192,
+		},
+	}
+	flags := Flags{
+		DBPath:     strPtr("/flag.db"),
+		ListenAddr: strPtr("0.0.0.0:1234"),
+	}
+	env := Environ{"ORCA_DB": "/env.db"}
+	out := cfg.MergeOverrides(flags, env)
+	if out.DBPath != "/flag.db" {
+		t.Errorf("DBPath=%q want /flag.db", out.DBPath)
+	}
+	if out.ListenAddr != "0.0.0.0:1234" {
+		t.Errorf("ListenAddr=%q want 0.0.0.0:1234", out.ListenAddr)
+	}
+	if cfg.DBPath != "/file.db" {
+		t.Errorf("receiver mutated: %q", cfg.DBPath)
+	}
+}
+
+func TestMergeOverrides_EnvWinsOverFile(t *testing.T) {
+	cfg := &Config{DBPath: "/file.db", ListenAddr: "127.0.0.1:9000"}
+	env := Environ{"ORCA_DB": "/env.db"}
+	out := cfg.MergeOverrides(Flags{}, env)
+	if out.DBPath != "/env.db" {
+		t.Errorf("DBPath=%q want /env.db", out.DBPath)
+	}
+	if out.ListenAddr != "127.0.0.1:9000" {
+		t.Errorf("ListenAddr=%q want 127.0.0.1:9000", out.ListenAddr)
+	}
+}
+
+func TestMergeOverrides_FileWinsOverDefault(t *testing.T) {
+	cfg := &Config{DBPath: "/file.db", ListenAddr: "127.0.0.1:9000"}
+	out := cfg.MergeOverrides(Flags{}, Environ{})
+	if out.DBPath != "/file.db" {
+		t.Errorf("DBPath=%q want /file.db", out.DBPath)
+	}
+	if out.ListenAddr != "127.0.0.1:9000" {
+		t.Errorf("ListenAddr=%q want 127.0.0.1:9000", out.ListenAddr)
+	}
+}
+
+func TestMergeOverrides_EmptyFlagDoesNotOverride(t *testing.T) {
+	cfg := &Config{DBPath: "/file.db"}
+	env := Environ{"ORCA_DB": "/env.db"}
+	out := cfg.MergeOverrides(Flags{}, env)
+	if out.DBPath != "/env.db" {
+		t.Errorf("DBPath=%q want /env.db", out.DBPath)
+	}
+}
+
+func TestMergeOverrides_EmptyEnvDoesNotOverride(t *testing.T) {
+	cfg := &Config{DBPath: "/file.db"}
+	env := Environ{"ORCA_DB": ""}
+	out := cfg.MergeOverrides(Flags{}, env)
+	if out.DBPath != "/file.db" {
+		t.Errorf("DBPath=%q want /file.db", out.DBPath)
+	}
+}
+
+func TestMergeOverrides_NodeCapacity(t *testing.T) {
+	cfg := &Config{
+		NodeCapacity: &CapacityConfig{CPU: 4, MemoryMB: 8192},
+	}
+	out := cfg.MergeOverrides(Flags{}, Environ{})
+	if out.NodeCapacity == nil {
+		t.Fatal("NodeCapacity nil")
+	}
+	if out.NodeCapacity.CPU != 4 {
+		t.Errorf("CPU=%d want 4", out.NodeCapacity.CPU)
+	}
+	if out.NodeCapacity.MemoryMB != 8192 {
+		t.Errorf("MemoryMB=%d want 8192", out.NodeCapacity.MemoryMB)
+	}
+	if cfg.NodeCapacity == out.NodeCapacity {
+		t.Error("NodeCapacity not cloned")
+	}
+}
+
+func TestMergeOverrides_NodeCapacityFlagAndEnv(t *testing.T) {
+	cfg := &Config{NodeCapacity: &CapacityConfig{CPU: 4, MemoryMB: 8192}}
+	flags := Flags{CPU: intPtr(8)}
+	env := Environ{"ORCA_NODE_MEMORY_MB": "16384"}
+	out := cfg.MergeOverrides(flags, env)
+	if out.NodeCapacity.CPU != 8 {
+		t.Errorf("CPU=%d want 8", out.NodeCapacity.CPU)
+	}
+	if out.NodeCapacity.MemoryMB != 16384 {
+		t.Errorf("MemoryMB=%d want 16384", out.NodeCapacity.MemoryMB)
+	}
+}

internal/config/testdata/config.hcl

@@ -0,0 +1,10 @@
+db_path          = "/tmp/orca/test.db"
+listen_addr      = "127.0.0.1:9999"
+ca_path          = "/tmp/orca/ca.crt"
+server_cert_path = "/tmp/orca/server.crt"
+server_key_path  = "/tmp/orca/server.key"
+
+node_capacity {
+  cpu       = 4
+  memory_mb = 8192
+}

internal/doctor/doctor.go

@@ -25,8 +25,12 @@ import (
 	"strings"
 	"time"
 
+	"golang.org/x/crypto/ssh"
+	"golang.org/x/crypto/ssh/knownhosts"
+
 	"git.cloudinit.dev/coreci/orca/internal/certpaths"
 	"git.cloudinit.dev/coreci/orca/internal/model"
+	"git.cloudinit.dev/coreci/orca/internal/osdetect"
 	"git.cloudinit.dev/coreci/orca/internal/security"
 	"git.cloudinit.dev/coreci/orca/internal/store"
 	"git.cloudinit.dev/coreci/orca/internal/transport"
@@ -68,7 +72,9 @@ func All() []Check {
 		CertServer(),
 		CertExpiry(),
 		CertFingerprint(),
+		OS(),
 		Network(),
+		Proxmox(),
 		DB(),
 	}
 }
@@ -300,6 +306,179 @@ func probeHealthz(ctx context.Context, caPath, certPath, keyPath, serverName, ad
 	return nil
 }
 
+// OS checks that the auto-detected OS matches the stored localhost
+// node's os field (REQ-052). Drift (e.g., OS upgraded since init)
+// returns WARN; match returns PASS; missing localhost node returns FAIL.
+func OS() Check {
+	return Check{
+		Name:        "os",
+		Description: "localhost OS detection vs stored node row",
+		Run: func(ctx context.Context) (Result, string) {
+			detected := osdetect.Detect()
+
+			db, err := store.Open(certpaths.DBPath())
+			if err != nil {
+				return ResultFail, fmt.Sprintf("open db: %v", err)
+			}
+			defer db.Close()
+
+			node, err := store.NewNodeRepo(db).GetByName(ctx, "localhost")
+			if err == store.ErrNotFound {
+				return ResultFail, "no localhost node registered — run `orca init`"
+			}
+			if err != nil {
+				return ResultFail, fmt.Sprintf("lookup localhost node: %v", err)
+			}
+			if node.OS == "" {
+				return ResultWarn, fmt.Sprintf("localhost node has no os field (pre-0006 row?); detected=%s — re-run `orca init` to refresh", detected)
+			}
+			if node.OS != detected {
+				return ResultWarn, fmt.Sprintf("OS drift: init=%s, now=%s — re-run `orca init` to refresh", node.OS, detected)
+			}
+			return ResultPass, fmt.Sprintf("localhost os=%s (matches /etc/os-release)", detected)
+		},
+	}
+}
+
+// Proxmox probes each kind=proxmox node via SSH with `pveversion`
+// (REQ-052). Clones the Network() pattern: list nodes, filter by kind,
+// 3s timeout per peer, PASS/WARN/FAIL per node. Zero proxmox nodes
+// returns WARN (single-node cluster is legitimate).
+func Proxmox() Check {
+	return Check{
+		Name:        "proxmox",
+		Description: "proxmox node reachability via SSH pveversion probe",
+		Run: func(ctx context.Context) (Result, string) {
+			db, err := store.Open(certpaths.DBPath())
+			if err != nil {
+				return ResultFail, fmt.Sprintf("open db: %v", err)
+			}
+			defer db.Close()
+
+			nodes, err := store.NewNodeRepo(db).List(ctx)
+			if err != nil {
+				return ResultFail, fmt.Sprintf("list nodes: %v", err)
+			}
+
+			proxmoxNodes := make([]*model.Node, 0, len(nodes))
+			for _, n := range nodes {
+				if n.Kind == string(model.NodeKindProxmox) && n.State != model.NodeStateLeft {
+					proxmoxNodes = append(proxmoxNodes, n)
+				}
+			}
+
+			if len(proxmoxNodes) == 0 {
+				return ResultWarn, "no proxmox nodes registered (single-node?)"
+			}
+
+			var lines []string
+			anyFail := false
+			for _, n := range proxmoxNodes {
+				probeCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
+				err := probeProxmoxPVEVersion(probeCtx, n.Name)
+				cancel()
+				if err != nil {
+					anyFail = true
+					lines = append(lines, fmt.Sprintf("  ✗ %s: %v", n.Name, err))
+				} else {
+					lines = append(lines, fmt.Sprintf("  ✓ %s", n.Name))
+				}
+			}
+
+			result := ResultPass
+			if anyFail {
+				result = ResultFail
+			}
+			return result, strings.Join(lines, "\n")
+		},
+	}
+}
+
+// probeProxmoxPVEVersion SSHes into the proxmox host and runs
+// `pveversion` to verify reachability + PVE installation. Uses the
+// orca SSH key for auth (deployed during `orca node join --type proxmox`)
+// and the known_hosts TOFU store for host-key verification (D-035).
+func probeProxmoxPVEVersion(ctx context.Context, host string) error {
+	// Load the orca SSH key for public-key auth.
+	keyPEM, err := os.ReadFile(certpaths.SSHKeyPath())
+	if err != nil {
+		return fmt.Errorf("read SSH key: %w (run `orca node join --type proxmox` first)", err)
+	}
+	signer, err := ssh.ParsePrivateKey(keyPEM)
+	if err != nil {
+		return fmt.Errorf("parse SSH key: %w", err)
+	}
+
+	hostKeyCallback, err := knownhosts.New(certpaths.KnownHostsPath())
+	if err != nil {
+		return fmt.Errorf("known_hosts: %w", err)
+	}
+
+	config := &ssh.ClientConfig{
+		User:            "orca",
+		Auth:            []ssh.AuthMethod{ssh.PublicKeys(signer)},
+		HostKeyCallback: hostKeyCallback,
+		Timeout:         3 * time.Second,
+	}
+
+	// Extract host from the node address (orca stores host:8443;
+	// SSH needs host:22). We dial the SSH port, not the orca daemon port.
+	sshHost := host
+	if strings.Contains(host, ":") {
+		sshHost = strings.SplitN(host, ":", 2)[0]
+	}
+	sshAddr := sshHost + ":22"
+
+	dialer := &netDialer{}
+	conn, err := dialer.DialContext(ctx, "tcp", sshAddr, config)
+	if err != nil {
+		return fmt.Errorf("ssh dial: %w", err)
+	}
+	defer conn.Close()
+
+	session, err := conn.NewSession()
+	if err != nil {
+		return fmt.Errorf("new session: %w", err)
+	}
+	defer session.Close()
+
+	out, err := session.CombinedOutput("pveversion")
+	if err != nil {
+		return fmt.Errorf("pveversion: %w (output: %s)", err, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
+// netDialer wraps ssh.Dial with context support. The ssh package's
+// Dial doesn't accept a context directly, so we use a dialer that
+// respects ctx cancellation via a goroutine + channel.
+type netDialer struct{}
+
+func (d *netDialer) DialContext(ctx context.Context, network, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
+	type result struct {
+		client *ssh.Client
+		err    error
+	}
+	ch := make(chan result, 1)
+	go func() {
+		client, err := ssh.Dial(network, addr, config)
+		ch <- result{client, err}
+	}()
+	select {
+	case <-ctx.Done():
+		// Best-effort: if the dial succeeds after ctx cancellation,
+		// the goroutine will close the client. We return the ctx error.
+		go func() {
+			if r := <-ch; r.client != nil {
+				_ = r.client.Close()
+			}
+		}()
+		return nil, ctx.Err()
+	case r := <-ch:
+		return r.client, r.err
+	}
+}
+
 // loadCert reads a PEM cert from path and parses the first CERTIFICATE
 // block.
 func loadCert(path string) (*x509.Certificate, error) {

internal/doctor/doctor_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"git.cloudinit.dev/coreci/orca/internal/model"
+	"git.cloudinit.dev/coreci/orca/internal/osdetect"
 	"git.cloudinit.dev/coreci/orca/internal/security"
 	"git.cloudinit.dev/coreci/orca/internal/store"
 )
@@ -134,7 +135,7 @@ func TestDBCheck_IntegrityOK(t *testing.T) {
 	if r != ResultPass {
 		t.Errorf("DB check: got %s, want PASS — %s", r, msg)
 	}
-	if !strings.Contains(msg, "0005") {
+	if !strings.Contains(msg, "migrations up to") {
 		t.Errorf("DB check message should contain migration version, got: %s", msg)
 	}
 }
@@ -241,6 +242,156 @@ func TestRenderReport(t *testing.T) {
 	}
 }
 
+// TestOSCheck_MissingLocalhostNode verifies the OS check returns FAIL
+// when no localhost node is registered.
+func TestOSCheck_MissingLocalhostNode(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("ORCA_HOME", dir)
+	t.Setenv("ORCA_DB", filepath.Join(dir, "orca.db"))
+
+	// Open the DB to apply migrations but insert no nodes.
+	db, err := store.Open(filepath.Join(dir, "orca.db"))
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	db.Close()
+
+	c := OS()
+	r, msg := c.Run(context.Background())
+	if r != ResultFail {
+		t.Errorf("OS check: got %s, want FAIL — %s", r, msg)
+	}
+	if !strings.Contains(msg, "no localhost node") {
+		t.Errorf("OS check message should mention missing localhost node, got: %s", msg)
+	}
+}
+
+// TestOSCheck_Match verifies the OS check returns PASS when the stored
+// localhost node's os matches the detected OS.
+func TestOSCheck_Match(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("ORCA_HOME", dir)
+	t.Setenv("ORCA_DB", filepath.Join(dir, "orca.db"))
+
+	db, err := store.Open(filepath.Join(dir, "orca.db"))
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	defer db.Close()
+	repo := store.NewNodeRepo(db)
+
+	// Insert a localhost node with the currently-detected OS.
+	detected := osdetect.Detect()
+	if err := repo.Insert(context.Background(), &model.Node{
+		ID: "os-match-1", Name: "localhost", Address: "localhost:8443",
+		State: model.NodeStateReady, JoinedAt: time.Now().UTC(), LastSeen: time.Now().UTC(),
+		Kind: "localhost", OS: detected,
+	}); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	c := OS()
+	r, msg := c.Run(context.Background())
+	if r != ResultPass {
+		t.Errorf("OS check: got %s, want PASS — %s", r, msg)
+	}
+	if !strings.Contains(msg, detected) {
+		t.Errorf("OS check message should contain %s, got: %s", detected, msg)
+	}
+}
+
+// TestOSCheck_Drift verifies the OS check returns WARN when the stored
+// os differs from the detected os.
+func TestOSCheck_Drift(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("ORCA_HOME", dir)
+	t.Setenv("ORCA_DB", filepath.Join(dir, "orca.db"))
+
+	db, err := store.Open(filepath.Join(dir, "orca.db"))
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	defer db.Close()
+	repo := store.NewNodeRepo(db)
+
+	// Insert a localhost node with a deliberately wrong OS.
+	if err := repo.Insert(context.Background(), &model.Node{
+		ID: "os-drift-1", Name: "localhost", Address: "localhost:8443",
+		State: model.NodeStateReady, JoinedAt: time.Now().UTC(), LastSeen: time.Now().UTC(),
+		Kind: "localhost", OS: "debian",
+	}); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	c := OS()
+	r, msg := c.Run(context.Background())
+	if r != ResultWarn {
+		t.Errorf("OS check: got %s, want WARN — %s", r, msg)
+	}
+	if !strings.Contains(msg, "drift") {
+		t.Errorf("OS check message should mention drift, got: %s", msg)
+	}
+}
+
+// TestProxmoxCheck_NoProxmoxNodes verifies the proxmox check returns
+// WARN when no proxmox nodes are registered.
+func TestProxmoxCheck_NoProxmoxNodes(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("ORCA_HOME", dir)
+	t.Setenv("ORCA_DB", filepath.Join(dir, "orca.db"))
+
+	db, err := store.Open(filepath.Join(dir, "orca.db"))
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	defer db.Close()
+
+	c := Proxmox()
+	r, msg := c.Run(context.Background())
+	if r != ResultWarn {
+		t.Errorf("Proxmox check: got %s, want WARN — %s", r, msg)
+	}
+	if !strings.Contains(msg, "no proxmox nodes") {
+		t.Errorf("Proxmox check message should mention no proxmox nodes, got: %s", msg)
+	}
+}
+
+// TestProxmoxCheck_UnreachableNode verifies the proxmox check returns
+// FAIL when a proxmox node is registered but unreachable (no SSH key
+// or host down). We insert a proxmox node with an unreachable address;
+// the SSH dial will fail (no SSH key file → error).
+func TestProxmoxCheck_UnreachableNode(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("ORCA_HOME", dir)
+	t.Setenv("ORCA_DB", filepath.Join(dir, "orca.db"))
+
+	db, err := store.Open(filepath.Join(dir, "orca.db"))
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	defer db.Close()
+	repo := store.NewNodeRepo(db)
+
+	// Insert a proxmox node. The SSH probe will fail because no SSH
+	// key exists in the test namespace dir.
+	if err := repo.Insert(context.Background(), &model.Node{
+		ID: "px-1", Name: "10.0.0.99", Address: "10.0.0.99:8443",
+		State: model.NodeStateReady, JoinedAt: time.Now().UTC(), LastSeen: time.Now().UTC(),
+		Kind: "proxmox", OS: "pve",
+	}); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	c := Proxmox()
+	r, msg := c.Run(context.Background())
+	if r != ResultFail {
+		t.Errorf("Proxmox check: got %s, want FAIL — %s", r, msg)
+	}
+	if !strings.Contains(msg, "10.0.0.99") {
+		t.Errorf("Proxmox check message should mention the node, got: %s", msg)
+	}
+}
+
 func init() {
 	// Suppress slog noise during tests.
 	_ = os.Setenv("ORCA_LOG_LEVEL", "error")

internal/engine/dispatcher_test.go

@@ -0,0 +1,205 @@
+package engine
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"testing"
+
+	"git.cloudinit.dev/coreci/orca/internal/store"
+)
+
+type mockExecutor struct {
+	submitFn  func(ctx context.Context, spec []byte) (string, error)
+	statusFn  func(ctx context.Context, jobID string) (string, error)
+	submitted bool
+}
+
+func (m *mockExecutor) Submit(ctx context.Context, spec []byte) (string, error) {
+	m.submitted = true
+	if m.submitFn != nil {
+		return m.submitFn(ctx, spec)
+	}
+	return "mock-job-id", nil
+}
+
+func (m *mockExecutor) Status(ctx context.Context, jobID string) (string, error) {
+	if m.statusFn != nil {
+		return m.statusFn(ctx, jobID)
+	}
+	return "complete", nil
+}
+
+func newTestDispatcher(t *testing.T, exec LocalExecutor) (*Dispatcher, *store.CapacityRepo, func()) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "test.db")
+	db, err := store.Open(path)
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	capRepo := store.NewCapacityRepo(db)
+	peers := NewPeerRegistry()
+	d := NewDispatcher(nil, capRepo, peers, exec)
+	return d, capRepo, func() { _ = db.Close() }
+}
+
+func TestDispatcher_Submit_EmptySpec(t *testing.T) {
+	d, _, cleanup := newTestDispatcher(t, &mockExecutor{})
+	defer cleanup()
+	_, _, err := d.Submit(context.Background(), "", nil, "")
+	if err == nil {
+		t.Fatal("Submit: expected error for empty spec, got nil")
+	}
+}
+
+func TestDispatcher_Submit_IdempotencyHit(t *testing.T) {
+	exec := &mockExecutor{}
+	d, _, cleanup := newTestDispatcher(t, exec)
+	defer cleanup()
+
+	d.Dedupe().Put("key-1", "cached-job-id")
+	spec := []byte(`{"cpu_millicores":100,"memory_mib":64,"disk_mib":64}`)
+	jobID, nodeID, err := d.Submit(context.Background(), "", spec, "key-1")
+	if err != nil {
+		t.Fatalf("Submit: %v", err)
+	}
+	if jobID != "cached-job-id" {
+		t.Errorf("jobID: got %q, want cached-job-id", jobID)
+	}
+	if nodeID != "self" {
+		t.Errorf("nodeID: got %q, want self", nodeID)
+	}
+	if exec.submitted {
+		t.Error("executor was called on idempotency hit; should have been short-circuited")
+	}
+}
+
+func TestDispatcher_Submit_LocalCapacity(t *testing.T) {
+	exec := &mockExecutor{
+		submitFn: func(ctx context.Context, spec []byte) (string, error) {
+			return "local-job-id", nil
+		},
+	}
+	d, capRepo, cleanup := newTestDispatcher(t, exec)
+	defer cleanup()
+	ctx := context.Background()
+	if err := capRepo.Upsert(ctx, &store.NodeCapacity{
+		NodeID:        "self",
+		CPUMillicores: 4000,
+		MemoryMiB:     4096,
+		DiskMiB:       4096,
+	}); err != nil {
+		t.Fatalf("Upsert capacity: %v", err)
+	}
+	spec := []byte(`{"cpu_millicores":100,"memory_mib":64,"disk_mib":64}`)
+	jobID, nodeID, err := d.Submit(ctx, "", spec, "")
+	if err != nil {
+		t.Fatalf("Submit: %v", err)
+	}
+	if jobID != "local-job-id" {
+		t.Errorf("jobID: got %q, want local-job-id", jobID)
+	}
+	if nodeID != "self" {
+		t.Errorf("nodeID: got %q, want self", nodeID)
+	}
+	if !exec.submitted {
+		t.Error("executor was not called for local-capacity path")
+	}
+}
+
+func TestDispatcher_Submit_ExplicitTarget(t *testing.T) {
+	exec := &mockExecutor{}
+	d, _, cleanup := newTestDispatcher(t, exec)
+	defer cleanup()
+	spec := []byte(`{"cpu_millicores":100,"memory_mib":64,"disk_mib":64}`)
+	_, _, err := d.Submit(context.Background(), "nodeA", spec, "")
+	if err == nil {
+		t.Fatal("Submit with explicit target nodeA (no peer): expected error, got nil")
+	}
+}
+
+func TestDispatcher_Submit_NoPeers(t *testing.T) {
+	exec := &mockExecutor{}
+	d, capRepo, cleanup := newTestDispatcher(t, exec)
+	defer cleanup()
+	ctx := context.Background()
+	if err := capRepo.Upsert(ctx, &store.NodeCapacity{
+		NodeID:        "self",
+		CPUMillicores: 0,
+		MemoryMiB:     0,
+		DiskMiB:       0,
+	}); err != nil {
+		t.Fatalf("Upsert: %v", err)
+	}
+	spec := []byte(`{"cpu_millicores":1000,"memory_mib":1024,"disk_mib":1024}`)
+	_, _, err := d.Submit(ctx, "", spec, "")
+	if err == nil {
+		t.Fatal("Submit: expected error when no peers and no local capacity, got nil")
+	}
+}
+
+func TestDispatcher_LocalSubmit(t *testing.T) {
+	exec := &mockExecutor{
+		submitFn: func(ctx context.Context, spec []byte) (string, error) {
+			return "ls-job", nil
+		},
+	}
+	d, _, cleanup := newTestDispatcher(t, exec)
+	defer cleanup()
+	jobID, err := d.LocalSubmit(context.Background(), []byte(`{"command":"/bin/true"}`))
+	if err != nil {
+		t.Fatalf("LocalSubmit: %v", err)
+	}
+	if jobID != "ls-job" {
+		t.Errorf("LocalSubmit: got %q, want ls-job", jobID)
+	}
+	if !exec.submitted {
+		t.Error("LocalSubmit: executor.Submit not called")
+	}
+}
+
+func TestDispatcher_LocalStatus(t *testing.T) {
+	exec := &mockExecutor{
+		statusFn: func(ctx context.Context, jobID string) (string, error) {
+			if jobID == "known" {
+				return "running", nil
+			}
+			return "", errors.New("not found")
+		},
+	}
+	d, _, cleanup := newTestDispatcher(t, exec)
+	defer cleanup()
+	st, err := d.LocalStatus(context.Background(), "known")
+	if err != nil {
+		t.Fatalf("LocalStatus: %v", err)
+	}
+	if st != "running" {
+		t.Errorf("LocalStatus: got %q, want running", st)
+	}
+	if _, err := d.LocalStatus(context.Background(), "missing"); err == nil {
+		t.Error("LocalStatus: expected error for missing job, got nil")
+	}
+}
+
+func TestDispatcher_LocalSubmit_NilExecutor(t *testing.T) {
+	d := NewDispatcher(nil, nil, NewPeerRegistry(), nil)
+	if _, err := d.LocalSubmit(context.Background(), []byte(`{}`)); err == nil {
+		t.Error("LocalSubmit with nil executor: expected error, got nil")
+	}
+	if _, err := d.LocalStatus(context.Background(), "x"); err == nil {
+		t.Error("LocalStatus with nil executor: expected error, got nil")
+	}
+}
+
+func TestParseInlineSpec(t *testing.T) {
+	spec, err := parseInlineSpec([]byte(`{"cpu_millicores":500,"memory_mib":256,"disk_mib":128}`))
+	if err != nil {
+		t.Fatalf("parseInlineSpec: %v", err)
+	}
+	if spec.CPUMillicores != 500 || spec.MemoryMiB != 256 || spec.DiskMiB != 128 {
+		t.Errorf("parseInlineSpec: got %+v, want cpu=500 mem=256 disk=128", spec)
+	}
+	if _, err := parseInlineSpec([]byte(`{bad json`)); err == nil {
+		t.Fatal("parseInlineSpec: expected error for malformed JSON, got nil")
+	}
+}

internal/engine/executor_test.go

@@ -0,0 +1,145 @@
+package engine
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+
+	"git.cloudinit.dev/coreci/orca/internal/model"
+	"git.cloudinit.dev/coreci/orca/internal/store"
+)
+
+func newTestExecutor(t *testing.T) (*Executor, func()) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "test.db")
+	db, err := store.Open(path)
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	ex := NewExecutor(store.NewJobRepo(db), store.NewTaskRepo(db), nil)
+	return ex, func() { _ = db.Close() }
+}
+
+func TestExecutor_Submit_Success(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	ctx := context.Background()
+	spec := []byte(`{"command":"/bin/echo","args":["hello"]}`)
+	jobID, err := ex.Submit(ctx, spec)
+	if err != nil {
+		t.Fatalf("Submit: %v", err)
+	}
+	if jobID == "" {
+		t.Fatal("Submit: empty jobID")
+	}
+	status, err := ex.Status(ctx, jobID)
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status != string(model.JobStatusComplete) {
+		t.Errorf("Status: got %q, want %q", status, model.JobStatusComplete)
+	}
+}
+
+func TestExecutor_Submit_MissingCommand(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	_, err := ex.Submit(context.Background(), []byte(`{"name":"x"}`))
+	if err == nil {
+		t.Fatal("Submit: expected error for missing command, got nil")
+	}
+}
+
+func TestExecutor_Submit_MalformedJSON(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	_, err := ex.Submit(context.Background(), []byte(`{bad json`))
+	if err == nil {
+		t.Fatal("Submit: expected error for malformed JSON, got nil")
+	}
+}
+
+func TestExecutor_Submit_FailingCommand(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	ctx := context.Background()
+	jobID, err := ex.Submit(ctx, []byte(`{"command":"/bin/false"}`))
+	if err == nil {
+		t.Fatal("Submit failing command: expected error, got nil")
+	}
+	if jobID == "" {
+		t.Fatal("Submit failing command: empty jobID")
+	}
+	status, err := ex.Status(ctx, jobID)
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if status != string(model.JobStatusFailed) {
+		t.Errorf("Status: got %q, want %q", status, model.JobStatusFailed)
+	}
+}
+
+func TestExecutor_Status_NotFound(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	_, err := ex.Status(context.Background(), "nonexistent-job-id")
+	if err == nil {
+		t.Fatal("Status: expected error for missing job, got nil")
+	}
+}
+
+func TestExecutor_Run_Success(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	ctx := context.Background()
+	job := &model.Job{
+		ID:     uuid.NewString(),
+		Name:   "run-success",
+		Spec:   "{}",
+		Status: model.JobStatusPending,
+	}
+	specs := []TaskSpec{{Name: "echo", Command: "/bin/echo", Args: []string{"hi"}}}
+	if err := ex.Run(ctx, job, specs); err != nil {
+		t.Fatalf("Run: %v", err)
+	}
+	got, err := ex.Status(ctx, job.ID)
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if got != string(model.JobStatusComplete) {
+		t.Errorf("Status: got %q, want %q", got, model.JobStatusComplete)
+	}
+}
+
+func TestExecutor_Run_ContextCancel(t *testing.T) {
+	ex, cleanup := newTestExecutor(t)
+	defer cleanup()
+	ctx, cancel := context.WithCancel(context.Background())
+	job := &model.Job{
+		ID:     uuid.NewString(),
+		Name:   "run-cancel",
+		Spec:   "{}",
+		Status: model.JobStatusPending,
+	}
+	specs := []TaskSpec{{Name: "sleep", Command: "/bin/sleep", Args: []string{"10"}}}
+
+	go func() {
+		time.Sleep(100 * time.Millisecond)
+		cancel()
+	}()
+
+	err := ex.Run(ctx, job, specs)
+	if err == nil {
+		t.Fatal("Run: expected error after context cancel, got nil")
+	}
+	status, sErr := ex.Status(context.Background(), job.ID)
+	if sErr != nil {
+		t.Fatalf("Status after cancel: %v", sErr)
+	}
+	if status == string(model.JobStatusComplete) {
+		t.Errorf("Status: got %q, want not complete (task should have been killed)", status)
+	}
+}

internal/engine/peer_test.go

@@ -0,0 +1,136 @@
+package engine
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"git.cloudinit.dev/coreci/orca/internal/store"
+)
+
+func TestPeerRegistry_AddAndGet(t *testing.T) {
+	r := NewPeerRegistry()
+	p := &Peer{
+		NodeID:     "node-1",
+		Address:    "localhost:8443",
+		ServerName: "node-1.orca",
+		CAPath:     "/etc/orca/ca.pem",
+	}
+	if err := r.Add(p); err != nil {
+		t.Fatalf("Add: %v", err)
+	}
+	got := r.Get("node-1")
+	if got == nil {
+		t.Fatal("Get: returned nil after Add")
+	}
+	if got.NodeID != "node-1" || got.Address != "localhost:8443" ||
+		got.ServerName != "node-1.orca" || got.CAPath != "/etc/orca/ca.pem" {
+		t.Errorf("Get: fields mismatch: %+v", got)
+	}
+}
+
+func TestPeerRegistry_AddNil(t *testing.T) {
+	r := NewPeerRegistry()
+	if err := r.Add(nil); err == nil {
+		t.Fatal("Add(nil): expected error, got nil")
+	}
+}
+
+func TestPeerRegistry_AddMissingID(t *testing.T) {
+	r := NewPeerRegistry()
+	if err := r.Add(&Peer{Address: "a"}); err == nil {
+		t.Fatal("Add(empty NodeID): expected error, got nil")
+	}
+}
+
+func TestPeerRegistry_Remove(t *testing.T) {
+	r := NewPeerRegistry()
+	p := &Peer{NodeID: "node-r", Address: "a"}
+	if err := r.Add(p); err != nil {
+		t.Fatalf("Add: %v", err)
+	}
+	if !r.Remove("node-r") {
+		t.Fatal("Remove: returned false for existing peer")
+	}
+	if got := r.Get("node-r"); got != nil {
+		t.Errorf("Get after Remove: want nil, got %+v", got)
+	}
+	if r.Remove("node-r") {
+		t.Error("Remove second time: want false, got true")
+	}
+}
+
+func TestPeerRegistry_All(t *testing.T) {
+	r := NewPeerRegistry()
+	for _, id := range []string{"node-c", "node-a", "node-b"} {
+		if err := r.Add(&Peer{NodeID: id, Address: "a"}); err != nil {
+			t.Fatalf("Add %s: %v", id, err)
+		}
+	}
+	got, err := r.All(context.Background())
+	if err != nil {
+		t.Fatalf("All: %v", err)
+	}
+	if len(got) != 3 {
+		t.Fatalf("All: got %d, want 3", len(got))
+	}
+	want := []string{"node-a", "node-b", "node-c"}
+	for i, w := range want {
+		if got[i].NodeID != w {
+			t.Errorf("All[%d]: got %s, want %s (not sorted by NodeID)", i, got[i].NodeID, w)
+		}
+	}
+}
+
+func TestPeerRegistry_All_Empty(t *testing.T) {
+	r := NewPeerRegistry()
+	got, err := r.All(context.Background())
+	if err != nil {
+		t.Fatalf("All on empty: %v", err)
+	}
+	if len(got) != 0 {
+		t.Errorf("All on empty: got %d, want 0", len(got))
+	}
+}
+
+func TestPeerRegistry_Len(t *testing.T) {
+	r := NewPeerRegistry()
+	if r.Len() != 0 {
+		t.Errorf("Len on empty: got %d, want 0", r.Len())
+	}
+	if err := r.Add(&Peer{NodeID: "n1", Address: "a"}); err != nil {
+		t.Fatalf("Add n1: %v", err)
+	}
+	if err := r.Add(&Peer{NodeID: "n2", Address: "a"}); err != nil {
+		t.Fatalf("Add n2: %v", err)
+	}
+	if r.Len() != 2 {
+		t.Errorf("Len: got %d, want 2", r.Len())
+	}
+}
+
+func TestPeerRegistry_UpdateLastSeen(t *testing.T) {
+	r := NewPeerRegistry()
+	old := time.Now().Add(-1 * time.Hour).UTC()
+	p := &Peer{
+		NodeID:   "node-u",
+		Address:  "a",
+		LastSeen: old,
+		Capacity: &store.NodeCapacity{NodeID: "node-u", CPUMillicores: 1000, MemoryMiB: 1024, DiskMiB: 1024},
+	}
+	if err := r.Add(p); err != nil {
+		t.Fatalf("Add: %v", err)
+	}
+	r.UpdateLastSeen("node-u")
+	got := r.Get("node-u")
+	if got == nil {
+		t.Fatal("Get: nil after UpdateLastSeen")
+	}
+	if !got.LastSeen.After(old) {
+		t.Errorf("UpdateLastSeen: LastSeen not bumped; old=%v now=%v", old, got.LastSeen)
+	}
+	if time.Since(got.LastSeen) > 5*time.Second {
+		t.Errorf("UpdateLastSeen: LastSeen not recent: %v", got.LastSeen)
+	}
+	r.UpdateLastSeen("nonexistent")
+}

internal/model/node.go

@@ -10,6 +10,19 @@ const (
 	NodeStateLeft    NodeState = "left"
 )
 
+// NodeKind classifies a node by how it joined the cluster.
+type NodeKind string
+
+const (
+	// NodeKindLocalhost is the auto-registered local node from `orca init`.
+	NodeKindLocalhost NodeKind = "localhost"
+	// NodeKindLinux is a generic Linux node (ubuntu/debian/alpine) joined
+	// without a specific type. Reserved for future SSH-join flows.
+	NodeKindLinux NodeKind = "linux"
+	// NodeKindProxmox is a Proxmox VE 8/9 host joined via SSH bootstrap.
+	NodeKindProxmox NodeKind = "proxmox"
+)
+
 type Node struct {
 	ID       string            `json:"id"`
 	Name     string            `json:"name"`
@@ -18,4 +31,10 @@ type Node struct {
 	JoinedAt time.Time         `json:"joined_at"`
 	LastSeen time.Time         `json:"last_seen"`
 	Metadata map[string]string `json:"metadata,omitempty"`
+	// Kind classifies the node: localhost | linux | proxmox (REQ-049).
+	// Empty string for rows created before migration 0006.
+	Kind string `json:"kind,omitempty"`
+	// OS is the auto-detected OS identifier from /etc/os-release ID=
+	// (ubuntu|debian|alpine|pve|linux). Empty for pre-0006 rows.
+	OS string `json:"os,omitempty"`
 }

internal/osdetect/osdetect.go

@@ -0,0 +1,63 @@
+// Package osdetect provides OS detection from /etc/os-release (D-032).
+// It's a separate package to avoid import cycles between internal/cli
+// and internal/doctor (both need to detect the local OS).
+package osdetect
+
+import (
+	"bufio"
+	"os"
+	"strings"
+)
+
+// osReleasePaths are checked in order for the os-release file. The
+// freedesktop.org spec says /etc/os-release is the canonical path,
+// with /usr/lib/os-release as a fallback for minimal containers that
+// may not symlink the former.
+var osReleasePaths = []string{"/etc/os-release", "/usr/lib/os-release"}
+
+// Detect reads /etc/os-release (then /usr/lib/os-release as a
+// fallback) and returns the value of the ID= field. Returns "linux"
+// (the generic fallback per D-032) if the file is missing, the ID
+// field is absent, or the value is empty. Unknown ID values (e.g.
+// "fedora", "arch") are returned verbatim — doctor os can warn on
+// unknown values, but orca init must not fail.
+func Detect() string {
+	for _, p := range osReleasePaths {
+		data, err := os.ReadFile(p)
+		if err != nil {
+			continue
+		}
+		if id := ParseID(data); id != "" {
+			return id
+		}
+	}
+	return "linux"
+}
+
+// ParseID extracts the ID= value from os-release content.
+// The format is shell-compatible KEY=VALUE lines; values may be
+// double-quoted. Returns "" if ID is absent or empty.
+func ParseID(data []byte) string {
+	scanner := bufio.NewScanner(strings.NewReader(string(data)))
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		key, value, ok := strings.Cut(line, "=")
+		if !ok {
+			continue
+		}
+		key = strings.TrimSpace(key)
+		if key != "ID" {
+			continue
+		}
+		value = strings.TrimSpace(value)
+		// Strip surrounding double quotes (freedesktop spec allows quoted values).
+		if len(value) >= 2 && value[0] == '"' && value[len(value)-1] == '"' {
+			value = value[1 : len(value)-1]
+		}
+		return value
+	}
+	return ""
+}

internal/osdetect/osdetect_test.go

@@ -0,0 +1,103 @@
+package osdetect
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestParseID_Ubuntu(t *testing.T) {
+	content := `NAME="Ubuntu"
+VERSION="24.04.4 LTS (Noble Numbat)"
+ID=ubuntu
+ID_LIKE=debian`
+	if got := ParseID([]byte(content)); got != "ubuntu" {
+		t.Errorf("got %q, want ubuntu", got)
+	}
+}
+
+func TestParseID_Debian(t *testing.T) {
+	if got := ParseID([]byte("ID=debian\n")); got != "debian" {
+		t.Errorf("got %q, want debian", got)
+	}
+}
+
+func TestParseID_Alpine(t *testing.T) {
+	if got := ParseID([]byte("ID=alpine\n")); got != "alpine" {
+		t.Errorf("got %q, want alpine", got)
+	}
+}
+
+func TestParseID_PVE(t *testing.T) {
+	if got := ParseID([]byte("ID=pve\nID_LIKE=debian\n")); got != "pve" {
+		t.Errorf("got %q, want pve", got)
+	}
+}
+
+func TestParseID_QuotedValue(t *testing.T) {
+	if got := ParseID([]byte(`ID="ubuntu"` + "\n")); got != "ubuntu" {
+		t.Errorf("got %q, want ubuntu", got)
+	}
+}
+
+func TestParseID_MissingID(t *testing.T) {
+	if got := ParseID([]byte("NAME=Test\n")); got != "" {
+		t.Errorf("got %q, want empty", got)
+	}
+}
+
+func TestParseID_UnknownIDVerbatim(t *testing.T) {
+	if got := ParseID([]byte("ID=fedora\n")); got != "fedora" {
+		t.Errorf("got %q, want fedora", got)
+	}
+}
+
+func TestParseID_CommentsAndBlanks(t *testing.T) {
+	content := `# comment
+
+NAME="Test"
+# ID below
+ID=arch`
+	if got := ParseID([]byte(content)); got != "arch" {
+		t.Errorf("got %q, want arch", got)
+	}
+}
+
+func TestDetect_FallbackToLinux(t *testing.T) {
+	orig := osReleasePaths
+	defer func() { osReleasePaths = orig }()
+	osReleasePaths = []string{filepath.Join(t.TempDir(), "nonexistent")}
+	if got := Detect(); got != "linux" {
+		t.Errorf("got %q, want linux (fallback)", got)
+	}
+}
+
+func TestDetect_ReadsFile(t *testing.T) {
+	dir := t.TempDir()
+	orig := osReleasePaths
+	defer func() { osReleasePaths = orig }()
+	path := filepath.Join(dir, "os-release")
+	osReleasePaths = []string{path}
+	if err := os.WriteFile(path, []byte("ID=ubuntu\n"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if got := Detect(); got != "ubuntu" {
+		t.Errorf("got %q, want ubuntu", got)
+	}
+}
+
+func TestDetect_FallbackToUsrLib(t *testing.T) {
+	dir := t.TempDir()
+	orig := osReleasePaths
+	defer func() { osReleasePaths = orig }()
+	osReleasePaths = []string{
+		filepath.Join(dir, "etc"),     // missing
+		filepath.Join(dir, "usr-lib"), // fallback
+	}
+	if err := os.WriteFile(osReleasePaths[1], []byte("ID=alpine\n"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if got := Detect(); got != "alpine" {
+		t.Errorf("got %q, want alpine (from fallback)", got)
+	}
+}

internal/proxmox/bootstrap.go

@@ -0,0 +1,346 @@
+// Package proxmox implements the SSH-based bootstrap of a remote
+// Proxmox VE 8/9 host as an orca node (REQ-050, REQ-051).
+//
+// The bootstrap sequence (run via `orca node join --type proxmox`):
+//  1. Generate or load the orca SSH keypair (Ed25519, D-037)
+//  2. SSH dial with password auth + TOFU host-key capture (D-035)
+//  3. Deploy the orca pubkey to ~orca/.ssh/authorized_keys
+//  4. Create the `orca` Linux system user (config-overridable name)
+//  5. Create the OrcaOperator PVE role with least-privilege privileges
+//  6. Create the orca@pam PVE user (maps to the Linux system user)
+//  7. Assign the OrcaOperator role to orca@pam on path /
+//  8. Write /etc/sudoers.d/orca with NOEXEC on pct/qm, no NOEXEC on
+//     apt-get/dpkg, and pvesh EXCLUDED (AD-020: pvesh can bypass NOEXEC
+//     via the API execute endpoint)
+//  9. Validate the sudoers file with visudo -cf
+//  10. Return the node metadata for the caller to persist
+//
+// All steps are idempotent (D-036): re-running the bootstrap on an
+// already-configured host is a no-op. The password is never persisted
+// (D-031) — it is used only for the initial SSH auth and pubkey
+// deployment; subsequent orca→Proxmox access uses the deployed SSH key.
+package proxmox
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"strings"
+	"time"
+
+	"golang.org/x/crypto/ssh"
+	"golang.org/x/crypto/ssh/knownhosts"
+
+	"git.cloudinit.dev/coreci/orca/internal/certpaths"
+	"git.cloudinit.dev/coreci/orca/internal/security"
+)
+
+// DefaultProxmoxUser is the default Linux system user created on the
+// Proxmox host. Overridable via Options.ProxmoxUser.
+const DefaultProxmoxUser = "orca"
+
+// DefaultProxmoxRole is the default PVE custom role created for the
+// orca user. Overridable via Options.ProxmoxRole.
+const DefaultProxmoxRole = "OrcaOperator"
+
+// DefaultSSHPort is the default SSH port for Proxmox hosts.
+const DefaultSSHPort = 22
+
+// OrcaOperatorPrivileges is the least-privilege privilege set for the
+// OrcaOperator PVE role (D-033). Space-separated per pveum --privs
+// syntax. VM.Audit covers CTs as well (both live under /vms/{vmid}).
+const OrcaOperatorPrivileges = "VM.Audit Datastore.AllocateSpace SDN.Use"
+
+// Options configures a Proxmox bootstrap run.
+type Options struct {
+	// Host is the Proxmox host address (IP or hostname, no port).
+	Host string
+	// SSHUser is the initial SSH username (default "root").
+	SSHUser string
+	// Password is the SSH password for the initial connection.
+	// NEVER persisted (D-031). The caller must zero this after use.
+	Password string
+	// ProxmoxUser is the Linux system user to create on the host
+	// (default "orca"). Config-overridable.
+	ProxmoxUser string
+	// ProxmoxRole is the PVE custom role to create (default
+	// "OrcaOperator"). Config-overridable.
+	ProxmoxRole string
+	// SSHPort is the SSH port (default 22).
+	SSHPort int
+	// Logger receives audit-log entries. If nil, slog.Default() is used.
+	Logger *slog.Logger
+}
+
+// Result is the outcome of a successful bootstrap.
+type Result struct {
+	// NodeName is the name to use for the node in the orca registry
+	// (typically the host address).
+	NodeName string
+	// NodeAddress is the orca daemon address on the Proxmox host
+	// (host:8443 — the orca daemon port).
+	NodeAddress string
+	// HostKeyFingerprint is the SHA-256 fingerprint of the captured
+	// SSH host key (for operator verification).
+	HostKeyFingerprint string
+}
+
+// BootstrapProxmox runs the full SSH bootstrap sequence on a remote
+// Proxmox VE 8/9 host. All steps are idempotent. Returns a Result
+// describing the node to register, or an error if any step fails.
+func BootstrapProxmox(ctx context.Context, opts Options) (*Result, error) {
+	if opts.Host == "" {
+		return nil, fmt.Errorf("proxmox bootstrap: host is required")
+	}
+	if opts.Password == "" {
+		return nil, fmt.Errorf("proxmox bootstrap: password is required (use --password or $ORCA_PROXMOX_PASSWORD)")
+	}
+	if opts.SSHUser == "" {
+		opts.SSHUser = "root"
+	}
+	if opts.ProxmoxUser == "" {
+		opts.ProxmoxUser = DefaultProxmoxUser
+	}
+	if opts.ProxmoxRole == "" {
+		opts.ProxmoxRole = DefaultProxmoxRole
+	}
+	if opts.SSHPort == 0 {
+		opts.SSHPort = DefaultSSHPort
+	}
+	log := opts.Logger
+	if log == nil {
+		log = slog.Default()
+	}
+
+	// Step 1: Generate or load the orca SSH keypair (D-037).
+	// The key is deployed to the remote host's authorized_keys in step 3.
+	_, pubLine, err := security.GenerateOrLoadSSHKey(certpaths.Dir())
+	if err != nil {
+		return nil, fmt.Errorf("ssh key: %w", err)
+	}
+
+	// Step 2: SSH dial with password auth + TOFU host-key capture (D-035).
+	// knownhosts.New reads ~/.orca/known_hosts; on first connect it
+	// captures the host key, on subsequent connects it verifies.
+	hostKeyCallback, err := knownhosts.New(certpaths.KnownHostsPath())
+	if err != nil {
+		return nil, fmt.Errorf("known_hosts callback: %w", err)
+	}
+
+	sshAddr := fmt.Sprintf("%s:%d", opts.Host, opts.SSHPort)
+	sshConfig := &ssh.ClientConfig{
+		User:            opts.SSHUser,
+		Auth:            []ssh.AuthMethod{ssh.Password(opts.Password)},
+		HostKeyCallback: hostKeyCallback,
+		Timeout:         10 * time.Second,
+	}
+
+	dialCtx, dialCancel := context.WithTimeout(ctx, 15*time.Second)
+	defer dialCancel()
+	conn, err := sshDialer.DialContext(dialCtx, "tcp", sshAddr, sshConfig)
+	if err != nil {
+		return nil, fmt.Errorf("ssh dial %s: %w", sshAddr, err)
+	}
+	defer conn.Close()
+
+	log.Info("proxmox.ssh_connected",
+		slog.String("event", "proxmox.ssh_connected"),
+		slog.String("host", opts.Host),
+		slog.String("ssh_user", opts.SSHUser),
+	)
+
+	// Step 3: Deploy orca pubkey to ~orca/.ssh/authorized_keys (idempotent).
+	if err := deployPubKey(conn, opts.ProxmoxUser, string(pubLine)); err != nil {
+		return nil, fmt.Errorf("deploy pubkey: %w", err)
+	}
+
+	// Step 4: Create orca Linux system user (idempotent).
+	if err := createLinuxUser(conn, opts.ProxmoxUser); err != nil {
+		return nil, fmt.Errorf("create user %s: %w", opts.ProxmoxUser, err)
+	}
+
+	// Step 5: Create OrcaOperator PVE role (idempotent).
+	if err := createPVERole(conn, opts.ProxmoxRole); err != nil {
+		return nil, fmt.Errorf("create PVE role %s: %w", opts.ProxmoxRole, err)
+	}
+
+	// Step 6: Create orca@pam PVE user (idempotent).
+	if err := createPVEUser(conn, opts.ProxmoxUser); err != nil {
+		return nil, fmt.Errorf("create PVE user %s@pam: %w", opts.ProxmoxUser, err)
+	}
+
+	// Step 7: Assign OrcaOperator role to orca@pam on path / (idempotent).
+	if err := assignPVEACL(conn, opts.ProxmoxUser, opts.ProxmoxRole); err != nil {
+		return nil, fmt.Errorf("assign ACL: %w", err)
+	}
+
+	// Step 8: Write /etc/sudoers.d/orca (AD-020: NOEXEC on pct/qm,
+	// no NOEXEC on apt-get/dpkg, pvesh EXCLUDED).
+	if err := writeSudoers(conn, opts.ProxmoxUser); err != nil {
+		return nil, fmt.Errorf("write sudoers: %w", err)
+	}
+
+	// Step 9: Validate sudoers with visudo -cf.
+	if err := validateSudoers(conn); err != nil {
+		return nil, fmt.Errorf("validate sudoers: %w", err)
+	}
+
+	log.Info("proxmox.bootstrap_ok",
+		slog.String("event", "proxmox.bootstrap_ok"),
+		slog.String("host", opts.Host),
+		slog.String("proxmox_user", opts.ProxmoxUser),
+		slog.String("proxmox_role", opts.ProxmoxRole),
+	)
+
+	return &Result{
+		NodeName:    opts.Host,
+		NodeAddress: opts.Host + ":8443",
+	}, nil
+}
+
+// sshDialer is the dialer used by BootstrapProxmox. It's a package-level
+// variable so tests can override it with a fake SSH server.
+var sshDialer sshDialerType = defaultSSHDialer{}
+
+type sshDialerType interface {
+	DialContext(ctx context.Context, network, addr string, config *ssh.ClientConfig) (*ssh.Client, error)
+}
+
+type defaultSSHDialer struct{}
+
+func (defaultSSHDialer) DialContext(ctx context.Context, network, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
+	return ssh.Dial(network, addr, config)
+}
+
+// runRemote runs a command over the SSH connection and returns its
+// combined output. Returns an error if the command exits non-zero.
+func runRemote(conn *ssh.Client, cmd string) ([]byte, error) {
+	session, err := conn.NewSession()
+	if err != nil {
+		return nil, fmt.Errorf("new session: %w", err)
+	}
+	defer session.Close()
+	out, err := session.CombinedOutput(cmd)
+	if err != nil {
+		return out, fmt.Errorf("run %q: %w (output: %s)", cmd, err, strings.TrimSpace(string(out)))
+	}
+	return out, nil
+}
+
+// deployPubKey appends the orca public key to the remote user's
+// authorized_keys file, creating the .ssh dir if needed. Idempotent:
+// if the key is already present, it is not re-appended.
+func deployPubKey(conn *ssh.Client, user, pubLine string) error {
+	pubLine = strings.TrimSpace(pubLine)
+	if pubLine == "" {
+		return fmt.Errorf("deployPubKey: empty pub line")
+	}
+	home := "/home/" + user
+	if user == "root" {
+		home = "/root"
+	}
+	sshDir := home + "/.ssh"
+	authFile := sshDir + "/authorized_keys"
+	// Create .ssh dir, touch authorized_keys, set modes, append key if absent.
+	cmd := fmt.Sprintf(
+		"mkdir -p %s && touch %s && chmod 0700 %s && chmod 0600 %s && grep -qF '%s' %s || echo '%s' >> %s",
+		sshDir, authFile, sshDir, authFile, pubLine, authFile, pubLine, authFile,
+	)
+	if _, err := runRemote(conn, cmd); err != nil {
+		return err
+	}
+	return nil
+}
+
+// createLinuxUser creates the orca system user if it doesn't already
+// exist. Idempotent: `id -u` check before `useradd`.
+func createLinuxUser(conn *ssh.Client, user string) error {
+	cmd := fmt.Sprintf("id -u %s 2>/dev/null || useradd -m -s /bin/bash %s", user, user)
+	if _, err := runRemote(conn, cmd); err != nil {
+		return err
+	}
+	return nil
+}
+
+// createPVERole creates the OrcaOperator PVE role if it doesn't exist.
+// Idempotent: probes `pveum role list` before `pveum role add`.
+func createPVERole(conn *ssh.Client, role string) error {
+	cmd := fmt.Sprintf(
+		"pveum role list 2>/dev/null | grep -q '^%s' || pveum role add %s --privs '%s'",
+		role, role, OrcaOperatorPrivileges,
+	)
+	if _, err := runRemote(conn, cmd); err != nil {
+		return err
+	}
+	return nil
+}
+
+// createPVEUser creates the orca@pam PVE user if it doesn't exist.
+// Idempotent: probes `pveum user list` before `pveum user add`.
+// Uses @pam realm (AD-019) since orca creates a Linux system user.
+func createPVEUser(conn *ssh.Client, user string) error {
+	pveUserID := user + "@pam"
+	cmd := fmt.Sprintf(
+		"pveum user list 2>/dev/null | grep -q '%s' || pveum user add %s -comment 'Orca automation user'",
+		pveUserID, pveUserID,
+	)
+	if _, err := runRemote(conn, cmd); err != nil {
+		return err
+	}
+	return nil
+}
+
+// assignPVEACL assigns the OrcaOperator role to orca@pam on path /
+// (cluster-wide). `pveum acl modify` is idempotent (creates or updates).
+func assignPVEACL(conn *ssh.Client, user, role string) error {
+	pveUserID := user + "@pam"
+	cmd := fmt.Sprintf("pveum acl modify / -user %s -role %s", pveUserID, role)
+	if _, err := runRemote(conn, cmd); err != nil {
+		return err
+	}
+	return nil
+}
+
+// sudoersContent returns the /etc/sudoers.d/orca file content (AD-020).
+// NOEXEC on pct/qm (blocks shell escapes); no NOEXEC on apt-get/dpkg
+// (they need exec for maintainer scripts); pvesh EXCLUDED (API execute
+// bypasses NOEXEC). File must be mode 0440 per sudo requirements.
+func sudoersContent(user string) string {
+	return fmt.Sprintf(`# /etc/sudoers.d/orca — Managed by orca; do not edit manually.
+# Least-privilege allowlist for the orca PVE operator user.
+# NOPASSWD: non-interactive SSH automation. NOEXEC: blocks shell escapes.
+# pvesh is EXCLUDED (AD-020: pvesh can bypass NOEXEC via API execute).
+%s ALL=(root) NOPASSWD: NOEXEC: /usr/bin/pct
+%s ALL=(root) NOPASSWD: NOEXEC: /usr/bin/qm
+%s ALL=(root) NOPASSWD: /usr/bin/apt-get
+%s ALL=(root) NOPASSWD: /usr/bin/dpkg
+`, user, user, user, user)
+}
+
+// writeSudoers writes the /etc/sudoers.d/orca file on the remote host
+// with mode 0440. Uses a heredoc via cat to avoid quoting issues.
+func writeSudoers(conn *ssh.Client, user string) error {
+	content := sudoersContent(user)
+	// Write via cat heredoc, then chmod 0440.
+	cmd := fmt.Sprintf("cat > /etc/sudoers.d/%s <<'ORCA_SUDOERS_EOF'\n%s\nORCA_SUDOERS_EOF\nchmod 0440 /etc/sudoers.d/%s",
+		user, content, user)
+	if _, err := runRemote(conn, cmd); err != nil {
+		return err
+	}
+	return nil
+}
+
+// validateSudoers runs `visudo -cf` on the sudoers file. Aborts the
+// bootstrap if validation fails (prevents a broken sudoers from
+// locking the orca user out of sudo).
+func validateSudoers(conn *ssh.Client) error {
+	cmd := "visudo -cf /etc/sudoers.d/orca"
+	out, err := runRemote(conn, cmd)
+	if err != nil {
+		return fmt.Errorf("visudo validation failed: %w (output: %s)", err, strings.TrimSpace(string(out)))
+	}
+	if !strings.Contains(string(out), "parsed OK") {
+		return fmt.Errorf("visudo validation did not report OK: %s", strings.TrimSpace(string(out)))
+	}
+	return nil
+}

internal/proxmox/bootstrap_test.go

@@ -0,0 +1,332 @@
+package proxmox
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/crypto/ssh"
+)
+
+func TestSudoersContent(t *testing.T) {
+	content := sudoersContent("orca")
+
+	if !strings.Contains(content, "NOPASSWD: NOEXEC: /usr/bin/pct") {
+		t.Error("missing NOEXEC on pct (AD-020)")
+	}
+	if !strings.Contains(content, "NOPASSWD: NOEXEC: /usr/bin/qm") {
+		t.Error("missing NOEXEC on qm (AD-020)")
+	}
+
+	if !strings.Contains(content, "NOPASSWD: /usr/bin/apt-get") {
+		t.Error("missing NOPASSWD on apt-get")
+	}
+	if !strings.Contains(content, "NOPASSWD: /usr/bin/dpkg") {
+		t.Error("missing NOPASSWD on dpkg")
+	}
+	if strings.Contains(content, "NOEXEC: /usr/bin/apt-get") {
+		t.Error("apt-get must NOT have NOEXEC (breaks maintainer scripts)")
+	}
+	if strings.Contains(content, "NOEXEC: /usr/bin/dpkg") {
+		t.Error("dpkg must NOT have NOEXEC (breaks maintainer scripts)")
+	}
+
+	for _, line := range strings.Split(content, "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "#") || trimmed == "" {
+			continue
+		}
+		if strings.Contains(trimmed, "pvesh") {
+			t.Errorf("pvesh must be EXCLUDED from sudoers command lines (AD-020): %s", trimmed)
+		}
+	}
+
+	if !strings.HasPrefix(content, "# /etc/sudoers.d/orca") {
+		t.Error("missing managed-by-orca header")
+	}
+	if !strings.Contains(content, "orca ALL=(root)") {
+		t.Error("missing orca user in sudoers")
+	}
+}
+
+func TestSudoersContent_CustomUser(t *testing.T) {
+	content := sudoersContent("custom-orca")
+	if !strings.Contains(content, "custom-orca ALL=(root)") {
+		t.Error("missing custom-orca user in sudoers")
+	}
+}
+
+func TestOrcaOperatorPrivileges(t *testing.T) {
+	privs := strings.Fields(OrcaOperatorPrivileges)
+	expected := map[string]bool{
+		"VM.Audit":                true,
+		"Datastore.AllocateSpace": true,
+		"SDN.Use":                 true,
+	}
+	if len(privs) != 3 {
+		t.Errorf("expected 3 privileges, got %d: %v", len(privs), privs)
+	}
+	for _, p := range privs {
+		if !expected[p] {
+			t.Errorf("unexpected privilege %q", p)
+		}
+	}
+}
+
+func TestBootstrapProxmox_Validation(t *testing.T) {
+	ctx := context.Background()
+
+	_, err := BootstrapProxmox(ctx, Options{Password: "pw"})
+	if err == nil || !strings.Contains(err.Error(), "host is required") {
+		t.Errorf("expected host-required error, got %v", err)
+	}
+
+	_, err = BootstrapProxmox(ctx, Options{Host: "10.0.0.1"})
+	if err == nil || !strings.Contains(err.Error(), "password is required") {
+		t.Errorf("expected password-required error, got %v", err)
+	}
+}
+
+func TestDefaultOptions(t *testing.T) {
+	if DefaultProxmoxUser != "orca" {
+		t.Errorf("DefaultProxmoxUser = %q, want orca", DefaultProxmoxUser)
+	}
+	if DefaultProxmoxRole != "OrcaOperator" {
+		t.Errorf("DefaultProxmoxRole = %q, want OrcaOperator", DefaultProxmoxRole)
+	}
+	if DefaultSSHPort != 22 {
+		t.Errorf("DefaultSSHPort = %d, want 22", DefaultSSHPort)
+	}
+}
+
+type mockSSHDialer struct {
+	client   *ssh.Client
+	err      error
+	calls    int
+	lastAddr string
+	lastCfg  *ssh.ClientConfig
+}
+
+func (m *mockSSHDialer) DialContext(ctx context.Context, network, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
+	m.calls++
+	m.lastAddr = addr
+	m.lastCfg = config
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.client, nil
+}
+
+func setupORCAHome(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	t.Setenv("ORCA_HOME", dir)
+	knownHosts := filepath.Join(dir, "known_hosts")
+	if err := os.WriteFile(knownHosts, []byte{}, 0o600); err != nil {
+		t.Fatalf("create known_hosts: %v", err)
+	}
+	return dir
+}
+
+func TestBootstrapProxmox_SSHAuthFailure(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &mockSSHDialer{err: errors.New("ssh: handshake failed: ssh: unable to authenticate")}
+
+	setupORCAHome(t)
+
+	_, err := BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+	})
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	if !strings.Contains(err.Error(), "ssh") {
+		t.Errorf("error should mention ssh, got: %v", err)
+	}
+	if !strings.Contains(err.Error(), "ssh dial") {
+		t.Errorf("error should mention ssh dial, got: %v", err)
+	}
+}
+
+func TestBootstrapProxmox_SSHDialCalledWithCorrectAddr(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	dialer := &mockSSHDialer{err: errors.New("connection refused")}
+	sshDialer = dialer
+
+	setupORCAHome(t)
+
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.42",
+		Password: "pw",
+		SSHPort:  2222,
+	})
+	if dialer.calls != 1 {
+		t.Errorf("dialer calls = %d, want 1", dialer.calls)
+	}
+	if dialer.lastAddr != "10.0.0.42:2222" {
+		t.Errorf("dial addr = %q, want 10.0.0.42:2222", dialer.lastAddr)
+	}
+}
+
+func TestBootstrapProxmox_DefaultSSHPort(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	dialer := &mockSSHDialer{err: errors.New("connection refused")}
+	sshDialer = dialer
+
+	setupORCAHome(t)
+
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.99",
+		Password: "pw",
+	})
+	if dialer.lastAddr != "10.0.0.99:22" {
+		t.Errorf("dial addr = %q, want 10.0.0.99:22 (default port)", dialer.lastAddr)
+	}
+}
+
+func TestBootstrapProxmox_CustomSSHUser(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	dialer := &mockSSHDialer{err: errors.New("connection refused")}
+	sshDialer = dialer
+
+	setupORCAHome(t)
+
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+		SSHUser:  "custom-admin",
+	})
+	if dialer.calls != 1 {
+		t.Errorf("dialer calls = %d, want 1", dialer.calls)
+	}
+	if dialer.lastCfg == nil || dialer.lastCfg.User != "custom-admin" {
+		t.Errorf("ssh user not propagated, got %+v", dialer.lastCfg)
+	}
+}
+
+func TestBootstrapProxmox_SSHKeyGenerated(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &mockSSHDialer{err: errors.New("connection refused")}
+
+	dir := setupORCAHome(t)
+
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+	})
+
+	keyPath := filepath.Join(dir, "orca_ssh_key")
+	pubPath := filepath.Join(dir, "orca_ssh_key.pub")
+	if _, err := os.Stat(keyPath); err != nil {
+		t.Errorf("SSH key not generated at %s: %v", keyPath, err)
+	}
+	if _, err := os.Stat(pubPath); err != nil {
+		t.Errorf("SSH pub not generated at %s: %v", pubPath, err)
+	}
+}
+
+func TestBootstrapProxmox_KnownHostsFileCreated(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &mockSSHDialer{err: errors.New("connection refused")}
+
+	dir := setupORCAHome(t)
+
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+	})
+
+	knownHosts := filepath.Join(dir, "known_hosts")
+	if _, err := os.Stat(knownHosts); err != nil {
+		t.Errorf("known_hosts not created at %s: %v", knownHosts, err)
+	}
+}
+
+func TestBootstrapProxmox_NilLogger(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &mockSSHDialer{err: errors.New("connection refused")}
+
+	setupORCAHome(t)
+
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("nil logger panicked: %v", r)
+		}
+	}()
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+		Logger:   nil,
+	})
+}
+
+func TestBootstrapProxmox_CustomLogger(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &mockSSHDialer{err: errors.New("connection refused")}
+
+	setupORCAHome(t)
+
+	var buf bytes.Buffer
+	log := slog.New(slog.NewTextHandler(&buf, nil))
+
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("custom logger panicked: %v", r)
+		}
+	}()
+	_, _ = BootstrapProxmox(context.Background(), Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+		Logger:   log,
+	})
+	_ = buf.String()
+}
+
+func TestBootstrapProxmox_ContextCancelled(t *testing.T) {
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &mockSSHDialer{err: errors.New("connection refused")}
+
+	setupORCAHome(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	_, err := BootstrapProxmox(ctx, Options{
+		Host:     "10.0.0.1",
+		Password: "pw",
+	})
+	if err == nil {
+		t.Fatal("expected error with cancelled context")
+	}
+}
+
+func TestDeployPubKey_EmptyPubLine(t *testing.T) {
+	err := deployPubKey(nil, "orca", "")
+	if err == nil {
+		t.Error("expected error for empty pub line")
+	}
+	if !strings.Contains(err.Error(), "empty pub line") {
+		t.Errorf("error should mention empty pub line, got: %v", err)
+	}
+}
+
+func TestDeployPubKey_WhitespaceOnlyPubLine(t *testing.T) {
+	err := deployPubKey(nil, "orca", "   \n  \t  ")
+	if err == nil {
+		t.Error("expected error for whitespace-only pub line")
+	}
+}

internal/proxmox/ssh_session_test.go

@@ -0,0 +1,468 @@
+package proxmox
+
+import (
+	"bytes"
+	"context"
+	"crypto/ed25519"
+	"crypto/rand"
+	"errors"
+	"log/slog"
+	"net"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"golang.org/x/crypto/ssh"
+)
+
+type fakeSSHServer struct {
+	listener net.Listener
+	config   *ssh.ServerConfig
+	done     chan struct{}
+
+	mu      sync.Mutex
+	state   map[string]string
+	authDir string
+}
+
+func newFakeSSHServer(t *testing.T) *fakeSSHServer {
+	t.Helper()
+	_, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatalf("ed25519 gen: %v", err)
+	}
+	hostSigner, err := ssh.NewSignerFromKey(priv)
+	if err != nil {
+		t.Fatalf("ssh signer: %v", err)
+	}
+	config := &ssh.ServerConfig{
+		PasswordCallback: func(c ssh.ConnMetadata, password []byte) (*ssh.Permissions, error) {
+			if string(password) != "pw" {
+				return nil, errors.New("invalid password")
+			}
+			return nil, nil
+		},
+	}
+	config.AddHostKey(hostSigner)
+
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	srv := &fakeSSHServer{
+		listener: ln,
+		config:   config,
+		done:     make(chan struct{}),
+		state:    make(map[string]string),
+		authDir:  t.TempDir(),
+	}
+	go srv.serve()
+	return srv
+}
+
+func (s *fakeSSHServer) addr() string { return s.listener.Addr().String() }
+
+func (s *fakeSSHServer) serve() {
+	for {
+		conn, err := s.listener.Accept()
+		if err != nil {
+			close(s.done)
+			return
+		}
+		go s.handle(conn)
+	}
+}
+
+func (s *fakeSSHServer) handle(netConn net.Conn) {
+	defer netConn.Close()
+	_, chans, reqs, err := ssh.NewServerConn(netConn, s.config)
+	if err != nil {
+		return
+	}
+	go ssh.DiscardRequests(reqs)
+	for newChan := range chans {
+		if newChan.ChannelType() != "session" {
+			newChan.Reject(ssh.UnknownChannelType, "only session")
+			continue
+		}
+		go s.handleSession(newChan)
+	}
+}
+
+func (s *fakeSSHServer) handleSession(newChan ssh.NewChannel) {
+	ch, reqs, err := newChan.Accept()
+	if err != nil {
+		return
+	}
+	defer ch.Close()
+	for req := range reqs {
+		switch req.Type {
+		case "exec":
+			var execReq struct{ Command string }
+			if err := ssh.Unmarshal(req.Payload, &execReq); err != nil {
+				req.Reply(false, nil)
+				continue
+			}
+			req.Reply(true, nil)
+			out, code := s.runCommand(execReq.Command)
+			_, _ = ch.Write(out)
+			_, _ = ch.SendRequest("exit-status", false, ssh.Marshal(struct{ Code uint32 }{uint32(code)}))
+			_ = ch.Close()
+		default:
+			req.Reply(false, nil)
+		}
+	}
+}
+
+func (s *fakeSSHServer) runCommand(cmd string) ([]byte, int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	trimmed := strings.TrimSpace(cmd)
+	switch {
+	case trimmed == "echo hello":
+		return []byte("hello\n"), 0
+	case strings.HasPrefix(trimmed, "exit "):
+		return nil, 1
+	case strings.HasPrefix(trimmed, "id -u "):
+		return []byte("1000\n"), 0
+	case strings.Contains(trimmed, "pveum role list") || strings.Contains(trimmed, "pveum role add"):
+		s.state["pve_role:"+extractField(trimmed, "add ", " ")] = "ok"
+		return nil, 0
+	case strings.Contains(trimmed, "pveum user list") || strings.Contains(trimmed, "pveum user add"):
+		s.state["pve_user:orca@pam"] = "ok"
+		return nil, 0
+	case strings.Contains(trimmed, "pveum acl modify"):
+		s.state["pve_acl"] = "ok"
+		return nil, 0
+	case strings.HasPrefix(trimmed, "mkdir -p ") && strings.Contains(trimmed, "authorized_keys"):
+		return s.handleAuthKeyDeploy(trimmed)
+	case strings.HasPrefix(trimmed, "cat > /etc/sudoers.d/"):
+		return s.handleSudoersWrite(trimmed), 0
+	case strings.HasPrefix(trimmed, "visudo -cf /etc/sudoers.d/orca"):
+		if s.state["sudoers_valid"] == "true" {
+			return []byte("/etc/sudoers.d/orca: parsed OK\n"), 0
+		}
+		return []byte("/etc/sudoers.d/orca: syntax error\n"), 1
+	case strings.HasPrefix(trimmed, "cat /") && strings.HasSuffix(trimmed, "/authorized_keys"):
+		return s.readAuthFile(trimmed[4:]), 0
+	case strings.HasPrefix(trimmed, "cat /") && strings.Contains(trimmed, "/orca"):
+		return s.readSudoers(trimmed[4:]), 0
+	default:
+		return []byte("sh: command not found\n"), 127
+	}
+}
+
+func (s *fakeSSHServer) handleAuthKeyDeploy(cmd string) ([]byte, int) {
+	parts := strings.Split(cmd, "'")
+	var pubLine string
+	if len(parts) >= 2 {
+		pubLine = parts[1]
+	}
+	authPath := filepath.Join(s.authDir, "authorized_keys")
+	existing := string(s.readFile(authPath))
+	if !strings.Contains(existing, pubLine) {
+		existing += pubLine + "\n"
+	}
+	if err := os.WriteFile(authPath, []byte(existing), 0o600); err != nil {
+		return []byte("mkdir: permission denied\n"), 1
+	}
+	return nil, 0
+}
+
+func (s *fakeSSHServer) readAuthFile(path string) []byte {
+	if strings.HasSuffix(path, "/authorized_keys") {
+		return s.readFile(filepath.Join(s.authDir, "authorized_keys"))
+	}
+	return []byte("cat: " + path + ": No such file or directory\n")
+}
+
+func (s *fakeSSHServer) handleSudoersWrite(cmd string) []byte {
+	idx := strings.Index(cmd, "\n")
+	if idx < 0 {
+		return []byte("sh: bad heredoc\n")
+	}
+	content := cmd[idx+1:]
+	if end := strings.Index(content, "ORCA_SUDOERS_EOF"); end >= 0 {
+		content = content[:end]
+	}
+	s.state["sudoers_content"] = content
+	s.state["sudoers_valid"] = "true"
+	return nil
+}
+
+func (s *fakeSSHServer) readSudoers(path string) []byte {
+	if v, ok := s.state["sudoers_content"]; ok {
+		return []byte(v)
+	}
+	return []byte("cat: " + path + ": No such file or directory\n")
+}
+
+func (s *fakeSSHServer) readFile(path string) []byte {
+	b, _ := os.ReadFile(path)
+	return b
+}
+
+func (s *fakeSSHServer) close() {
+	s.listener.Close()
+	<-s.done
+}
+
+func extractField(s, after, until string) string {
+	i := strings.Index(s, after)
+	if i < 0 {
+		return ""
+	}
+	rest := s[i+len(after):]
+	j := strings.Index(rest, until)
+	if j < 0 {
+		return rest
+	}
+	return rest[:j]
+}
+
+func fakeSSHClient(t *testing.T, srv *fakeSSHServer) *ssh.Client {
+	t.Helper()
+	config := &ssh.ClientConfig{
+		User:            "root",
+		Auth:            []ssh.AuthMethod{ssh.Password("pw")},
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+		Timeout:         5 * time.Second,
+	}
+	client, err := ssh.Dial("tcp", srv.addr(), config)
+	if err != nil {
+		t.Fatalf("ssh.Dial: %v", err)
+	}
+	return client
+}
+
+func TestRunRemote_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	out, err := runRemote(conn, "echo hello")
+	if err != nil {
+		t.Fatalf("runRemote: %v", err)
+	}
+	if strings.TrimSpace(string(out)) != "hello" {
+		t.Errorf("output = %q, want hello", strings.TrimSpace(string(out)))
+	}
+}
+
+func TestRunRemote_Failure(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	_, err := runRemote(conn, "exit 7")
+	if err == nil {
+		t.Fatal("expected error for non-zero exit")
+	}
+	if !strings.Contains(err.Error(), "run") {
+		t.Errorf("error should mention run, got: %v", err)
+	}
+}
+
+func TestDeployPubKey_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+
+	if err := deployPubKey(conn, "orca", "ssh-ed25519 AAAA test@orca"); err != nil {
+		t.Fatalf("deployPubKey: %v", err)
+	}
+	out := srv.readFile(filepath.Join(srv.authDir, "authorized_keys"))
+	if !strings.Contains(string(out), "ssh-ed25519 AAAA test@orca") {
+		t.Errorf("auth file does not contain the key: %s", out)
+	}
+}
+
+func TestDeployPubKey_Idempotent(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+
+	if err := deployPubKey(conn, "orca", "ssh-ed25519 AAAA test@orca"); err != nil {
+		t.Fatalf("first deploy: %v", err)
+	}
+	if err := deployPubKey(conn, "orca", "ssh-ed25519 AAAA test@orca"); err != nil {
+		t.Fatalf("second deploy: %v", err)
+	}
+	out := srv.readFile(filepath.Join(srv.authDir, "authorized_keys"))
+	if cnt := strings.Count(string(out), "ssh-ed25519 AAAA test@orca"); cnt != 1 {
+		t.Errorf("key count = %d, want 1 (idempotent)", cnt)
+	}
+}
+
+func TestCreateLinuxUser_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	if err := createLinuxUser(conn, "orca"); err != nil {
+		t.Fatalf("createLinuxUser: %v", err)
+	}
+}
+
+func TestCreatePVERole_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	if err := createPVERole(conn, "OrcaOperator"); err != nil {
+		t.Fatalf("createPVERole: %v", err)
+	}
+}
+
+func TestCreatePVEUser_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	if err := createPVEUser(conn, "orca"); err != nil {
+		t.Fatalf("createPVEUser: %v", err)
+	}
+}
+
+func TestAssignPVEACL_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	if err := assignPVEACL(conn, "orca", "OrcaOperator"); err != nil {
+		t.Fatalf("assignPVEACL: %v", err)
+	}
+}
+
+func TestWriteSudoers_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+
+	if err := writeSudoers(conn, "orca"); err != nil {
+		t.Fatalf("writeSudoers: %v", err)
+	}
+	if srv.state["sudoers_valid"] != "true" {
+		t.Error("sudoers not marked valid")
+	}
+	if !strings.Contains(srv.state["sudoers_content"], "orca ALL=(root) NOPASSWD: NOEXEC: /usr/bin/pct") {
+		t.Errorf("sudoers content missing pct: %s", srv.state["sudoers_content"])
+	}
+}
+
+func TestValidateSudoers_ParsedOK(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+
+	srv.state["sudoers_valid"] = "true"
+	if err := validateSudoers(conn); err != nil {
+		t.Errorf("validateSudoers: %v", err)
+	}
+}
+
+func TestValidateSudoers_Failure(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+
+	srv.state["sudoers_valid"] = "false"
+	if err := validateSudoers(conn); err == nil {
+		t.Error("expected error for invalid sudoers")
+	}
+}
+
+type staticDialer struct {
+	client *ssh.Client
+}
+
+func (d *staticDialer) DialContext(ctx context.Context, network, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
+	return d.client, nil
+}
+
+func TestBootstrapProxmox_FullFlow_Success(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+
+	home := t.TempDir()
+	t.Setenv("ORCA_HOME", home)
+	if err := os.WriteFile(filepath.Join(home, "known_hosts"), []byte{}, 0o600); err != nil {
+		t.Fatalf("create known_hosts: %v", err)
+	}
+
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+	sshDialer = &staticDialer{client: fakeSSHClient(t, srv)}
+
+	host, _, _ := net.SplitHostPort(srv.addr())
+
+	var logBuf bytes.Buffer
+	result, err := BootstrapProxmox(t.Context(), Options{
+		Host:     host,
+		Password: "pw",
+		Logger:   slog.New(slog.NewTextHandler(&logBuf, nil)),
+	})
+	if err != nil {
+		t.Fatalf("BootstrapProxmox: %v", err)
+	}
+	if result == nil {
+		t.Fatal("result is nil")
+	}
+	if result.NodeName != host {
+		t.Errorf("NodeName = %q, want %q", result.NodeName, host)
+	}
+	if result.NodeAddress != host+":8443" {
+		t.Errorf("NodeAddress = %q, want %q:8443", result.NodeAddress, host)
+	}
+	if !strings.Contains(logBuf.String(), "proxmox.bootstrap_ok") {
+		t.Errorf("expected bootstrap_ok log, got: %s", logBuf.String())
+	}
+}
+
+func TestBootstrapProxmox_FullFlow_DeployPubKeyFails(t *testing.T) {
+	srv := newFakeSSHServer(t)
+	defer srv.close()
+
+	home := t.TempDir()
+	t.Setenv("ORCA_HOME", home)
+	if err := os.WriteFile(filepath.Join(home, "known_hosts"), []byte{}, 0o600); err != nil {
+		t.Fatalf("create known_hosts: %v", err)
+	}
+
+	orig := sshDialer
+	defer func() { sshDialer = orig }()
+
+	// Use a real client that connects to a server which will reject deploy
+	// by returning a non-zero exit for the mkdir command. We achieve this
+	// by using a dialer that returns a client to a server whose authDir
+	// is read-only — but simpler: just use a fresh server that errors on
+	// authorized_keys commands via a custom server. We reuse newFakeSSHServer
+	// but sabotage it by pointing authDir to a read-only location.
+	conn := fakeSSHClient(t, srv)
+	defer conn.Close()
+	sshDialer = &staticDialer{client: conn}
+
+	host, _, _ := net.SplitHostPort(srv.addr())
+
+	// Make authDir unwritable so deployPubKey's mkdir handler fails.
+	srv.authDir = "/proc/1/forbidden-orca-test"
+
+	_, err := BootstrapProxmox(t.Context(), Options{
+		Host:     host,
+		Password: "pw",
+	})
+	if err == nil {
+		t.Fatal("expected error from deployPubKey failure")
+	}
+	if !strings.Contains(err.Error(), "deploy pubkey") {
+		t.Errorf("error should mention deploy pubkey, got: %v", err)
+	}
+}

internal/security/sshkey.go

@@ -0,0 +1,95 @@
+package security
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/x509"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/crypto/ssh"
+)
+
+// SSHKeyMode is the file mode for the SSH private key. Matches the
+// CA key mode (REQ-033 spirit: 0600 for private keys).
+const SSHKeyMode os.FileMode = 0o600
+
+// SSHPubMode is the file mode for the SSH public key (authorized_keys
+// line). Matches the CA cert mode (0644 for public material).
+const SSHPubMode os.FileMode = 0o644
+
+const (
+	sshKeyFile = "orca_ssh_key"
+	sshPubFile = "orca_ssh_key.pub"
+)
+
+// GenerateOrLoadSSHKey returns the orca SSH keypair, generating it
+// lazily on first call (D-037). The key is Ed25519 (smaller, faster,
+// more secure than RSA for SSH auth), persisted as PKCS8 PEM to
+// dir/orca_ssh_key (0600) and dir/orca_ssh_key.pub (0644).
+//
+// Idempotent: if both files exist with valid content, they are loaded
+// and returned without regeneration. This matches the CAInit fast-path
+// pattern (D-036 idempotency).
+//
+// Returns:
+//   - keyPEM: PKCS8 PEM private key (parses with ssh.ParsePrivateKey)
+//   - pubLine: authorized_keys line (ssh-ed25519 AAAA... comment\n)
+func GenerateOrLoadSSHKey(dir string) (keyPEM, pubLine []byte, err error) {
+	if dir == "" {
+		return nil, nil, errors.New("GenerateOrLoadSSHKey: dir is required")
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return nil, nil, fmt.Errorf("GenerateOrLoadSSHKey: mkdir: %w", err)
+	}
+	keyPath := filepath.Join(dir, sshKeyFile)
+	pubPath := filepath.Join(dir, sshPubFile)
+
+	// Fast path: existing key — load and return.
+	if ok, err := bothExist(keyPath, pubPath); err != nil {
+		return nil, nil, err
+	} else if ok {
+		keyPEM, err := os.ReadFile(keyPath)
+		if err != nil {
+			return nil, nil, fmt.Errorf("read SSH key: %w", err)
+		}
+		pubLine, err := os.ReadFile(pubPath)
+		if err != nil {
+			return nil, nil, fmt.Errorf("read SSH pub: %w", err)
+		}
+		return keyPEM, pubLine, nil
+	}
+
+	// Generate Ed25519 keypair.
+	pub, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return nil, nil, fmt.Errorf("GenerateOrLoadSSHKey: ed25519 gen: %w", err)
+	}
+
+	// Serialize private key as PKCS8 PEM (consistent with ca.key/server.key).
+	keyDER, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		return nil, nil, fmt.Errorf("GenerateOrLoadSSHKey: marshal key: %w", err)
+	}
+	keyPEM = pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: keyDER})
+
+	// Serialize public key as authorized_keys line.
+	sshPub, err := ssh.NewPublicKey(pub)
+	if err != nil {
+		return nil, nil, fmt.Errorf("GenerateOrLoadSSHKey: new pubkey: %w", err)
+	}
+	pubLine = ssh.MarshalAuthorizedKey(sshPub)
+
+	// Persist with correct modes (atomic write + chmod).
+	if err := writeAtomic(keyPath, SSHKeyMode, keyPEM); err != nil {
+		return nil, nil, fmt.Errorf("write SSH key: %w", err)
+	}
+	if err := writeAtomic(pubPath, SSHPubMode, pubLine); err != nil {
+		return nil, nil, fmt.Errorf("write SSH pub: %w", err)
+	}
+
+	return keyPEM, pubLine, nil
+}

internal/security/sshkey_test.go

@@ -0,0 +1,93 @@
+package security
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/crypto/ssh"
+)
+
+func TestGenerateOrLoadSSHKey_Generates(t *testing.T) {
+	dir := t.TempDir()
+
+	keyPEM, pubLine, err := GenerateOrLoadSSHKey(dir)
+	if err != nil {
+		t.Fatalf("generate: %v", err)
+	}
+
+	// Private key file exists with mode 0600.
+	keyPath := filepath.Join(dir, sshKeyFile)
+	info, err := os.Stat(keyPath)
+	if err != nil {
+		t.Fatalf("stat key: %v", err)
+	}
+	if info.Mode().Perm() != SSHKeyMode {
+		t.Errorf("key mode = %04o, want %04o", info.Mode().Perm(), SSHKeyMode)
+	}
+
+	// Public key file exists with mode 0644.
+	pubPath := filepath.Join(dir, sshPubFile)
+	info, err = os.Stat(pubPath)
+	if err != nil {
+		t.Fatalf("stat pub: %v", err)
+	}
+	if info.Mode().Perm() != SSHPubMode {
+		t.Errorf("pub mode = %04o, want %04o", info.Mode().Perm(), SSHPubMode)
+	}
+
+	// Public key line is ssh-ed25519 format.
+	if !strings.HasPrefix(string(pubLine), "ssh-ed25519 ") {
+		t.Errorf("pub line = %q, want ssh-ed25519 prefix", string(pubLine))
+	}
+
+	// Private key PEM parses with ssh.ParsePrivateKey (PKCS8).
+	signer, err := ssh.ParsePrivateKey(keyPEM)
+	if err != nil {
+		t.Fatalf("parse private key: %v", err)
+	}
+	if signer.PublicKey().Type() != "ssh-ed25519" {
+		t.Errorf("signer key type = %q, want ssh-ed25519", signer.PublicKey().Type())
+	}
+}
+
+func TestGenerateOrLoadSSHKey_IdempotentLoad(t *testing.T) {
+	dir := t.TempDir()
+
+	// First call generates.
+	keyPEM1, pubLine1, err := GenerateOrLoadSSHKey(dir)
+	if err != nil {
+		t.Fatalf("first generate: %v", err)
+	}
+
+	// Second call loads existing.
+	keyPEM2, pubLine2, err := GenerateOrLoadSSHKey(dir)
+	if err != nil {
+		t.Fatalf("second load: %v", err)
+	}
+
+	if string(keyPEM1) != string(keyPEM2) {
+		t.Error("key was regenerated on second call (D-036 idempotency violation)")
+	}
+	if string(pubLine1) != string(pubLine2) {
+		t.Error("pub was regenerated on second call (D-036 idempotency violation)")
+	}
+}
+
+func TestGenerateOrLoadSSHKey_EmptyDir(t *testing.T) {
+	_, _, err := GenerateOrLoadSSHKey("")
+	if err == nil {
+		t.Error("expected error for empty dir")
+	}
+}
+
+func TestGenerateOrLoadSSHKey_CreatesDir(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "nested", "ssh-dir")
+	if _, _, err := GenerateOrLoadSSHKey(dir); err != nil {
+		t.Fatalf("generate with nested dir: %v", err)
+	}
+	if _, err := os.Stat(dir); err != nil {
+		t.Errorf("nested dir not created: %v", err)
+	}
+}

internal/store/cert_repo_test.go

@@ -0,0 +1,311 @@
+package store
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func openCertTestDB(t *testing.T) (*CertRepo, func()) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "test.db")
+	db, err := Open(path)
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	return NewCertRepo(db), func() { _ = db.Close() }
+}
+
+func sampleCert(id, nodeID, serial string, createdAt time.Time) *Cert {
+	return &Cert{
+		ID:          id,
+		Kind:        CertKindServer,
+		NodeID:      nodeID,
+		SerialHex:   serial,
+		SubjectCN:   "cn-" + id,
+		IssuerCN:    "issuer-" + id,
+		NotBefore:   createdAt.Add(-time.Hour),
+		NotAfter:    createdAt.Add(24 * time.Hour),
+		Fingerprint: "fp-" + id,
+		SourcePath:  "/path/" + id,
+		CreatedAt:   createdAt,
+	}
+}
+
+func TestCertRepo_InsertAndGet(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	createdAt := time.Now().UTC().Truncate(time.Second)
+	want := sampleCert("cert-1", "node-1", "AA", createdAt)
+
+	if err := repo.Insert(ctx, want); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	got, err := repo.Get(ctx, "cert-1")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.ID != want.ID {
+		t.Errorf("id = %q, want %q", got.ID, want.ID)
+	}
+	if got.Kind != want.Kind {
+		t.Errorf("kind = %q, want %q", got.Kind, want.Kind)
+	}
+	if got.NodeID != want.NodeID {
+		t.Errorf("node_id = %q, want %q", got.NodeID, want.NodeID)
+	}
+	if got.SerialHex != want.SerialHex {
+		t.Errorf("serial_hex = %q, want %q", got.SerialHex, want.SerialHex)
+	}
+	if got.SubjectCN != want.SubjectCN {
+		t.Errorf("subject_cn = %q, want %q", got.SubjectCN, want.SubjectCN)
+	}
+	if got.IssuerCN != want.IssuerCN {
+		t.Errorf("issuer_cn = %q, want %q", got.IssuerCN, want.IssuerCN)
+	}
+	if !got.NotBefore.Equal(want.NotBefore) {
+		t.Errorf("not_before = %v, want %v", got.NotBefore, want.NotBefore)
+	}
+	if !got.NotAfter.Equal(want.NotAfter) {
+		t.Errorf("not_after = %v, want %v", got.NotAfter, want.NotAfter)
+	}
+	if got.Fingerprint != want.Fingerprint {
+		t.Errorf("fingerprint = %q, want %q", got.Fingerprint, want.Fingerprint)
+	}
+	if got.SourcePath != want.SourcePath {
+		t.Errorf("source_path = %q, want %q", got.SourcePath, want.SourcePath)
+	}
+	if !got.CreatedAt.Equal(want.CreatedAt) {
+		t.Errorf("created_at = %v, want %v", got.CreatedAt, want.CreatedAt)
+	}
+}
+
+func TestCertRepo_InsertNil(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	if err := repo.Insert(ctx, nil); err == nil {
+		t.Fatal("expected error for nil cert, got nil")
+	}
+}
+
+func TestCertRepo_InsertMissingID(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	c := sampleCert("", "node-1", "AA", time.Now().UTC())
+	if err := repo.Insert(ctx, c); err == nil {
+		t.Fatal("expected error for missing ID, got nil")
+	}
+}
+
+func TestCertRepo_InsertMissingKind(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	c := sampleCert("cert-1", "node-1", "AA", time.Now().UTC())
+	c.Kind = ""
+	if err := repo.Insert(ctx, c); err == nil {
+		t.Fatal("expected error for missing Kind, got nil")
+	}
+}
+
+func TestCertRepo_InsertDuplicateSerial(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	c1 := sampleCert("cert-1", "node-1", "DUP", time.Now().UTC())
+	if err := repo.Insert(ctx, c1); err != nil {
+		t.Fatalf("insert c1: %v", err)
+	}
+	c2 := sampleCert("cert-2", "node-1", "DUP", time.Now().UTC())
+	if err := repo.Insert(ctx, c2); err == nil {
+		t.Fatal("expected error for duplicate serial_hex, got nil")
+	}
+}
+
+func TestCertRepo_GetMissing(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	_, err := repo.Get(ctx, "nope")
+	if err != ErrNotFound {
+		t.Errorf("expected ErrNotFound, got %v", err)
+	}
+}
+
+func TestCertRepo_List(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	base := time.Now().UTC()
+	ids := []string{"old", "mid", "new"}
+	for i, id := range ids {
+		c := sampleCert(id, "node-1", "S"+id, base.Add(time.Duration(i)*time.Second))
+		if err := repo.Insert(ctx, c); err != nil {
+			t.Fatalf("insert %s: %v", id, err)
+		}
+	}
+	got, err := repo.List(ctx)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(got) != 3 {
+		t.Fatalf("expected 3 certs, got %d", len(got))
+	}
+	wantOrder := []string{"new", "mid", "old"}
+	for i, want := range wantOrder {
+		if got[i].ID != want {
+			t.Errorf("list[%d].id = %q, want %q", i, got[i].ID, want)
+		}
+	}
+}
+
+func TestCertRepo_ListByNode(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	base := time.Now().UTC()
+	for i, id := range []string{"a1", "a2"} {
+		c := sampleCert(id, "nodeA", "SA"+id, base.Add(time.Duration(i)*time.Second))
+		if err := repo.Insert(ctx, c); err != nil {
+			t.Fatalf("insert %s: %v", id, err)
+		}
+	}
+	for i, id := range []string{"b1"} {
+		c := sampleCert(id, "nodeB", "SB"+id, base.Add(time.Duration(i)*time.Second))
+		if err := repo.Insert(ctx, c); err != nil {
+			t.Fatalf("insert %s: %v", id, err)
+		}
+	}
+
+	aCerts, err := repo.ListByNode(ctx, "nodeA")
+	if err != nil {
+		t.Fatalf("list nodeA: %v", err)
+	}
+	if len(aCerts) != 2 {
+		t.Errorf("expected 2 nodeA certs, got %d", len(aCerts))
+	}
+	for _, c := range aCerts {
+		if c.NodeID != "nodeA" {
+			t.Errorf("unexpected node_id %q in nodeA results", c.NodeID)
+		}
+	}
+
+	bCerts, err := repo.ListByNode(ctx, "nodeB")
+	if err != nil {
+		t.Fatalf("list nodeB: %v", err)
+	}
+	if len(bCerts) != 1 {
+		t.Errorf("expected 1 nodeB cert, got %d", len(bCerts))
+	}
+}
+
+func TestCertRepo_LatestForKind(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	base := time.Now().UTC()
+	older := sampleCert("old", "node-1", "O", base)
+	newer := sampleCert("new", "node-1", "N", base.Add(time.Minute))
+	if err := repo.Insert(ctx, older); err != nil {
+		t.Fatalf("insert old: %v", err)
+	}
+	if err := repo.Insert(ctx, newer); err != nil {
+		t.Fatalf("insert new: %v", err)
+	}
+
+	got, err := repo.LatestForKind(ctx, "node-1", CertKindServer)
+	if err != nil {
+		t.Fatalf("latest: %v", err)
+	}
+	if got.ID != "new" {
+		t.Errorf("latest.id = %q, want new", got.ID)
+	}
+
+	_, err = repo.LatestForKind(ctx, "node-empty", CertKindServer)
+	if err != ErrNotFound {
+		t.Errorf("expected ErrNotFound, got %v", err)
+	}
+}
+
+func TestCertRepo_PruneOlderThan(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	base := time.Now().UTC()
+	for i, id := range []string{"c1", "c2", "c3", "c4"} {
+		c := sampleCert(id, "node-1", "S"+id, base.Add(time.Duration(i)*time.Second))
+		if err := repo.Insert(ctx, c); err != nil {
+			t.Fatalf("insert %s: %v", id, err)
+		}
+	}
+
+	n, err := repo.PruneOlderThan(ctx, "node-1", string(CertKindServer), 3)
+	if err != nil {
+		t.Fatalf("prune: %v", err)
+	}
+	if n != 1 {
+		t.Errorf("expected 1 row deleted, got %d", n)
+	}
+	remaining, err := repo.ListByNode(ctx, "node-1")
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(remaining) != 3 {
+		t.Errorf("expected 3 remaining, got %d", len(remaining))
+	}
+	for _, c := range remaining {
+		if c.ID == "c1" {
+			t.Errorf("expected c1 pruned, but found")
+		}
+	}
+
+	n2, err := repo.PruneOlderThan(ctx, "node-1", string(CertKindServer), 0)
+	if err != nil {
+		t.Fatalf("prune keep=0: %v", err)
+	}
+	if n2 != 2 {
+		t.Errorf("keep=0 treated as keep=1: expected 2 deleted, got %d", n2)
+	}
+	remaining2, err := repo.ListByNode(ctx, "node-1")
+	if err != nil {
+		t.Fatalf("list after keep=0: %v", err)
+	}
+	if len(remaining2) != 1 {
+		t.Errorf("keep=0 treated as keep=1: expected 1 remaining, got %d", len(remaining2))
+	}
+	if remaining2[0].ID != "c4" {
+		t.Errorf("expected newest c4 retained, got %q", remaining2[0].ID)
+	}
+}
+
+func TestCertRepo_Delete(t *testing.T) {
+	repo, cleanup := openCertTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	c := sampleCert("cert-del", "node-1", "DEL", time.Now().UTC())
+	if err := repo.Insert(ctx, c); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+	if err := repo.Delete(ctx, "cert-del"); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+	if err := repo.Delete(ctx, "cert-del"); err != ErrNotFound {
+		t.Errorf("expected ErrNotFound on second delete, got %v", err)
+	}
+}

internal/store/migrate_test.go

@@ -19,8 +19,8 @@ func TestMigrationVersion(t *testing.T) {
 	if err != nil {
 		t.Fatalf("migration version: %v", err)
 	}
-	if version != "0005_node_capacity.sql" {
-		t.Errorf("MigrationVersion = %q, want 0005_node_capacity.sql", version)
+	if version != "0007_certs_serial_unique.sql" {
+		t.Errorf("MigrationVersion = %q, want 0007_certs_serial_unique.sql", version)
 	}
 
 	// Empty the migrations table → should return ("", nil).

internal/store/migrations/0006_node_kind_os.sql

@@ -0,0 +1,9 @@
+-- Node kind and OS columns (v0.6 P01, REQ-049).
+-- Nullable for backward compatibility: existing rows get NULL, which
+-- the Go scanNode helper maps to "" (empty string). New rows from
+-- `orca init` get kind='localhost', os=<detected>; proxmox joins get
+-- kind='proxmox', os='pve'.
+ALTER TABLE nodes ADD COLUMN kind TEXT;
+ALTER TABLE nodes ADD COLUMN os TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);

internal/store/migrations/0007_certs_serial_unique.sql

@@ -0,0 +1,5 @@
+-- Enforce uniqueness of serial_hex (ideation I-107): no two certs
+-- issued by orca may share the same serial. Implemented as a UNIQUE
+-- INDEX so existing 0004_certs.sql need not be re-run on deployed
+-- databases. v0.7 P01 (REQ-053 companion).
+CREATE UNIQUE INDEX IF NOT EXISTS idx_certs_serial_unique ON certs(serial_hex);

internal/store/node_repo.go

@@ -38,8 +38,8 @@ func (r *NodeRepo) Insert(ctx context.Context, n *model.Node) error {
 		return fmt.Errorf("marshal metadata: %w", err)
 	}
 	_, err = r.db.ExecContext(ctx,
-		`INSERT INTO nodes (id, name, address, state, joined_at, last_seen, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		n.ID, n.Name, n.Address, string(n.State), n.JoinedAt, n.LastSeen, string(metaJSON))
+		`INSERT INTO nodes (id, name, address, state, joined_at, last_seen, metadata, kind, os) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		n.ID, n.Name, n.Address, string(n.State), n.JoinedAt, n.LastSeen, string(metaJSON), n.Kind, n.OS)
 	if err != nil {
 		return fmt.Errorf("insert node: %w", err)
 	}
@@ -48,13 +48,19 @@ func (r *NodeRepo) Insert(ctx context.Context, n *model.Node) error {
 
 func (r *NodeRepo) Get(ctx context.Context, id string) (*model.Node, error) {
 	row := r.db.QueryRowContext(ctx,
-		`SELECT id, name, address, state, joined_at, last_seen, metadata FROM nodes WHERE id = ?`, id)
+		`SELECT id, name, address, state, joined_at, last_seen, metadata, kind, os FROM nodes WHERE id = ?`, id)
+	return scanNode(row)
+}
+
+func (r *NodeRepo) GetByName(ctx context.Context, name string) (*model.Node, error) {
+	row := r.db.QueryRowContext(ctx,
+		`SELECT id, name, address, state, joined_at, last_seen, metadata, kind, os FROM nodes WHERE name = ? ORDER BY joined_at ASC LIMIT 1`, name)
 	return scanNode(row)
 }
 
 func (r *NodeRepo) List(ctx context.Context) ([]*model.Node, error) {
 	rows, err := r.db.QueryContext(ctx,
-		`SELECT id, name, address, state, joined_at, last_seen, metadata FROM nodes ORDER BY joined_at ASC`)
+		`SELECT id, name, address, state, joined_at, last_seen, metadata, kind, os FROM nodes ORDER BY joined_at ASC`)
 	if err != nil {
 		return nil, fmt.Errorf("list nodes: %w", err)
 	}
@@ -77,7 +83,7 @@ func (r *NodeRepo) Watch(ctx context.Context) iter.Seq[[]*model.Node] {
 		defer ticker.Stop()
 		for {
 			rows, err := r.db.QueryContext(ctx,
-				`SELECT id, name, address, state, joined_at, last_seen, metadata FROM nodes ORDER BY joined_at ASC`)
+				`SELECT id, name, address, state, joined_at, last_seen, metadata, kind, os FROM nodes ORDER BY joined_at ASC`)
 			if err != nil {
 				slog.Default().Warn("watch nodes: query failed", "error", err)
 				// fall through to the select to wait for the next tick
@@ -119,6 +125,23 @@ func (r *NodeRepo) UpdateState(ctx context.Context, id string, state model.NodeS
 	return nil
 }
 
+// UpdateLastSeenAndOS refreshes the last_seen timestamp and os field
+// of an existing node without changing its id or joined_at. Used by
+// `orca init` re-runs to refresh the localhost node (D-036 idempotency).
+func (r *NodeRepo) UpdateLastSeenAndOS(ctx context.Context, id, os string) error {
+	res, err := r.db.ExecContext(ctx,
+		`UPDATE nodes SET last_seen = ?, os = ? WHERE id = ?`,
+		time.Now().UTC(), os, id)
+	if err != nil {
+		return fmt.Errorf("update node last_seen+os: %w", err)
+	}
+	rows, _ := res.RowsAffected()
+	if rows == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
 func (r *NodeRepo) Delete(ctx context.Context, id string) error {
 	res, err := r.db.ExecContext(ctx, `DELETE FROM nodes WHERE id = ?`, id)
 	if err != nil {
@@ -140,8 +163,10 @@ func scanNode(s scanner) (*model.Node, error) {
 		n        model.Node
 		state    string
 		metaJSON sql.NullString
+		kind     sql.NullString
+		os       sql.NullString
 	)
-	err := s.Scan(&n.ID, &n.Name, &n.Address, &state, &n.JoinedAt, &n.LastSeen, &metaJSON)
+	err := s.Scan(&n.ID, &n.Name, &n.Address, &state, &n.JoinedAt, &n.LastSeen, &metaJSON, &kind, &os)
 	if err == sql.ErrNoRows {
 		return nil, ErrNotFound
 	}
@@ -154,5 +179,8 @@ func scanNode(s scanner) (*model.Node, error) {
 			return nil, fmt.Errorf("unmarshal metadata: %w", err)
 		}
 	}
+	// Map SQL NULL → "" for backward compatibility with pre-0006 rows.
+	n.Kind = kind.String
+	n.OS = os.String
 	return &n, nil
 }

internal/store/node_repo_test.go

@@ -101,6 +101,119 @@ func TestNodeRepo_Delete(t *testing.T) {
 	}
 }
 
+func TestNodeRepo_KindOS_RoundTrip(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	n := &model.Node{
+		ID: "kind-os-1", Name: "localhost", Address: "localhost:8443",
+		State: model.NodeStateReady, JoinedAt: time.Now().UTC(), LastSeen: time.Now().UTC(),
+		Kind: string(model.NodeKindLocalhost), OS: "ubuntu",
+	}
+	if err := repo.Insert(ctx, n); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+	got, err := repo.Get(ctx, "kind-os-1")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Kind != "localhost" {
+		t.Errorf("kind = %q, want localhost", got.Kind)
+	}
+	if got.OS != "ubuntu" {
+		t.Errorf("os = %q, want ubuntu", got.OS)
+	}
+}
+
+func TestNodeRepo_NullKindOS_EmptyString(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	// Insert with empty Kind/OS — simulates a pre-0006 row or a node
+	// that doesn't set kind/os.
+	n := &model.Node{
+		ID: "null-kind-os", Name: "legacy", Address: "addr",
+		JoinedAt: time.Now().UTC(), LastSeen: time.Now().UTC(),
+	}
+	if err := repo.Insert(ctx, n); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+	got, err := repo.Get(ctx, "null-kind-os")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Kind != "" {
+		t.Errorf("kind = %q, want empty string for NULL", got.Kind)
+	}
+	if got.OS != "" {
+		t.Errorf("os = %q, want empty string for NULL", got.OS)
+	}
+}
+
+func TestNodeRepo_GetByName(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	_ = repo.Insert(ctx, &model.Node{
+		ID: "by-name-1", Name: "localhost", Address: "addr",
+		JoinedAt: time.Now().UTC(), LastSeen: time.Now().UTC(),
+		Kind: "localhost", OS: "ubuntu",
+	})
+
+	got, err := repo.GetByName(ctx, "localhost")
+	if err != nil {
+		t.Fatalf("get by name: %v", err)
+	}
+	if got.ID != "by-name-1" {
+		t.Errorf("id = %q, want by-name-1", got.ID)
+	}
+
+	_, err = repo.GetByName(ctx, "nonexistent")
+	if err != ErrNotFound {
+		t.Errorf("expected ErrNotFound, got %v", err)
+	}
+}
+
+func TestNodeRepo_UpdateLastSeenAndOS(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	original := time.Now().UTC().Add(-1 * time.Hour)
+	n := &model.Node{
+		ID: "update-os-1", Name: "localhost", Address: "addr",
+		JoinedAt: original, LastSeen: original,
+		Kind: "localhost", OS: "ubuntu",
+	}
+	if err := repo.Insert(ctx, n); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	if err := repo.UpdateLastSeenAndOS(ctx, "update-os-1", "debian"); err != nil {
+		t.Fatalf("update last_seen+os: %v", err)
+	}
+
+	got, err := repo.Get(ctx, "update-os-1")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.OS != "debian" {
+		t.Errorf("os = %q, want debian", got.OS)
+	}
+	if !got.LastSeen.After(original) {
+		t.Errorf("last_seen not refreshed: %v", got.LastSeen)
+	}
+	if !got.JoinedAt.Equal(original) {
+		t.Errorf("joined_at changed: was %v, now %v (D-036 violation)", original, got.JoinedAt)
+	}
+	if got.ID != "update-os-1" {
+		t.Errorf("id changed: %q (D-036 violation)", got.ID)
+	}
+}
+
 func insertNode(t *testing.T, repo *NodeRepo, ctx context.Context, id, name string) {
 	t.Helper()
 	if err := repo.Insert(ctx, &model.Node{

internal/transport/dispatch.go

@@ -14,6 +14,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"time"
 )
@@ -252,7 +253,7 @@ func bytesReader(b []byte) *bytesReadCloser { return &bytesReadCloser{b: b} }
 
 func (r *bytesReadCloser) Read(p []byte) (int, error) {
 	if r.pos >= len(r.b) {
-		return 0, fmt.Errorf("EOF")
+		return 0, io.EOF
 	}
 	n := copy(p, r.b[r.pos:])
 	r.pos += n

internal/transport/dispatch_test.go

@@ -0,0 +1,402 @@
+package transport
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"git.cloudinit.dev/coreci/orca/internal/security"
+)
+
+type mockDispatcher struct {
+	jobID     string
+	state     string
+	submitErr error
+	statusErr error
+	submits   int
+	statuses  int
+	lastSpec  []byte
+}
+
+func (m *mockDispatcher) LocalSubmit(ctx context.Context, spec []byte) (string, error) {
+	m.submits++
+	m.lastSpec = spec
+	if m.submitErr != nil {
+		return "", m.submitErr
+	}
+	if m.jobID == "" {
+		return "job-123", nil
+	}
+	return m.jobID, nil
+}
+
+func (m *mockDispatcher) LocalStatus(ctx context.Context, jobID string) (string, error) {
+	m.statuses++
+	if m.statusErr != nil {
+		return "", m.statusErr
+	}
+	if m.state == "" {
+		return "running", nil
+	}
+	return m.state, nil
+}
+
+func TestSubmitHandler_Success(t *testing.T) {
+	d := &mockDispatcher{}
+	h := NewSubmitHandler(d, nil)
+	body := bytes.NewReader([]byte(`{"spec":"{}"}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Submit", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("status = %d, want 200", w.Code)
+	}
+	var resp SubmitResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if resp.JobID != "job-123" {
+		t.Errorf("JobID = %q, want job-123", resp.JobID)
+	}
+	if d.submits != 1 {
+		t.Errorf("submits = %d, want 1", d.submits)
+	}
+}
+
+func TestSubmitHandler_IdempotencyReplay(t *testing.T) {
+	d := &mockDispatcher{}
+	store := NewIdempotencyStore()
+	store.Put("key-1", "job-existing")
+	h := NewSubmitHandler(d, store)
+	body := bytes.NewReader([]byte(`{"spec":"{}"}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Submit", body)
+	req.Header.Set(IdempotencyHeader, "key-1")
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("status = %d, want 200", w.Code)
+	}
+	var resp SubmitResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if resp.JobID != "job-existing" {
+		t.Errorf("JobID = %q, want job-existing (replay)", resp.JobID)
+	}
+	if d.submits != 0 {
+		t.Errorf("submits = %d, want 0 (replayed from store)", d.submits)
+	}
+}
+
+func TestSubmitHandler_IdempotencyStores(t *testing.T) {
+	d := &mockDispatcher{}
+	store := NewIdempotencyStore()
+	h := NewSubmitHandler(d, store)
+	body := bytes.NewReader([]byte(`{"spec":"{}"}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Submit", body)
+	req.Header.Set(IdempotencyHeader, "key-2")
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", w.Code)
+	}
+	if got, ok := store.Get("key-2"); !ok || got != "job-123" {
+		t.Errorf("store.Get(key-2) = (%q, %v), want (job-123, true)", got, ok)
+	}
+}
+
+func TestSubmitHandler_BadMethod(t *testing.T) {
+	h := NewSubmitHandler(&mockDispatcher{}, nil)
+	req := httptest.NewRequest(http.MethodGet, "/orca.v1.Dispatch/Submit", nil)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusMethodNotAllowed {
+		t.Errorf("status = %d, want 405", w.Code)
+	}
+}
+
+func TestSubmitHandler_BadBody(t *testing.T) {
+	h := NewSubmitHandler(&mockDispatcher{}, nil)
+	body := strings.NewReader("{not json")
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Submit", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want 400", w.Code)
+	}
+}
+
+func TestSubmitHandler_EmptySpec(t *testing.T) {
+	h := NewSubmitHandler(&mockDispatcher{}, nil)
+	body := bytes.NewReader([]byte(`{}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Submit", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want 400", w.Code)
+	}
+}
+
+func TestSubmitHandler_DispatcherError(t *testing.T) {
+	d := &mockDispatcher{submitErr: errors.New("boom")}
+	h := NewSubmitHandler(d, nil)
+	body := bytes.NewReader([]byte(`{"spec":"{}"}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Submit", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("status = %d, want 500", w.Code)
+	}
+}
+
+func TestStatusHandler_Success(t *testing.T) {
+	d := &mockDispatcher{state: "complete"}
+	h := NewStatusHandler(d)
+	body := bytes.NewReader([]byte(`{"job_id":"job-1"}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Status", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("status = %d, want 200", w.Code)
+	}
+	var resp StatusResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if resp.State != "complete" {
+		t.Errorf("State = %q, want complete", resp.State)
+	}
+}
+
+func TestStatusHandler_BadMethod(t *testing.T) {
+	h := NewStatusHandler(&mockDispatcher{})
+	req := httptest.NewRequest(http.MethodGet, "/orca.v1.Dispatch/Status", nil)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusMethodNotAllowed {
+		t.Errorf("status = %d, want 405", w.Code)
+	}
+}
+
+func TestStatusHandler_BadBody(t *testing.T) {
+	h := NewStatusHandler(&mockDispatcher{})
+	body := strings.NewReader("nope")
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Status", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want 400", w.Code)
+	}
+}
+
+func TestStatusHandler_EmptyJobID(t *testing.T) {
+	h := NewStatusHandler(&mockDispatcher{})
+	body := bytes.NewReader([]byte(`{"job_id":""}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Status", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("status = %d, want 400", w.Code)
+	}
+}
+
+func TestStatusHandler_DispatcherError(t *testing.T) {
+	d := &mockDispatcher{statusErr: errors.New("not found")}
+	h := NewStatusHandler(d)
+	body := bytes.NewReader([]byte(`{"job_id":"job-x"}`))
+	req := httptest.NewRequest(http.MethodPost, "/orca.v1.Dispatch/Status", body)
+	w := httptest.NewRecorder()
+	h.ServeHTTP(w, req)
+	if w.Code != http.StatusNotFound {
+		t.Errorf("status = %d, want 404", w.Code)
+	}
+}
+
+func TestNewDispatchClient(t *testing.T) {
+	dir := t.TempDir()
+	ca, err := security.CAInit(dir, "orca-test-ca")
+	if err != nil {
+		t.Fatalf("CAInit: %v", err)
+	}
+	caPath := filepath.Join(dir, security.CACertFile)
+	_ = ca
+	c, err := NewDispatchClient(caPath, "localhost", "https://localhost:8443")
+	if err != nil {
+		t.Fatalf("NewDispatchClient: %v", err)
+	}
+	if c == nil {
+		t.Fatal("client is nil")
+	}
+	if c.PeerAddr != "https://localhost:8443" {
+		t.Errorf("PeerAddr = %q, want https://localhost:8443", c.PeerAddr)
+	}
+}
+
+func TestNewDispatchClient_EmptyCAPath(t *testing.T) {
+	_, err := NewDispatchClient("", "localhost", "https://localhost:8443")
+	if err == nil {
+		t.Fatal("expected error for empty caPath")
+	}
+}
+
+func TestNewDispatchClient_EmptyServerName(t *testing.T) {
+	dir := t.TempDir()
+	_, err := security.CAInit(dir, "orca-test-ca")
+	caPath := filepath.Join(dir, security.CACertFile)
+	_, err = NewDispatchClient(caPath, "", "https://localhost:8443")
+	if err == nil {
+		t.Fatal("expected error for empty serverName")
+	}
+}
+
+func TestDispatchClient_InvalidURL(t *testing.T) {
+	dir := t.TempDir()
+	_, err := security.CAInit(dir, "orca-test-ca")
+	if err != nil {
+		t.Fatalf("CAInit: %v", err)
+	}
+	caPath := filepath.Join(dir, security.CACertFile)
+	c, err := NewDispatchClient(caPath, "localhost", "http://127.0.0.1:1")
+	if err != nil {
+		t.Fatalf("NewDispatchClient: %v", err)
+	}
+	_, err = c.Status(context.Background(), "job-1")
+	if err == nil {
+		t.Fatal("expected error for connection refused")
+	}
+}
+
+func TestDispatchClient_Status_HTTPError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		writeError(w, http.StatusInternalServerError, "boom")
+	}))
+	defer srv.Close()
+
+	dc := &DispatchClient{
+		HTTP:     &MTLSClient{http: &http.Client{Timeout: 5 * time.Second}},
+		PeerAddr: srv.URL,
+	}
+	_, err := dc.Status(context.Background(), "job-1")
+	if err == nil {
+		t.Fatal("expected error for 500 status")
+	}
+}
+
+func TestDispatchClient_Status_DecodeError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("{not valid json"))
+	}))
+	defer srv.Close()
+
+	dc := &DispatchClient{
+		HTTP:     &MTLSClient{http: &http.Client{Timeout: 5 * time.Second}},
+		PeerAddr: srv.URL,
+	}
+	_, err := dc.Status(context.Background(), "job-1")
+	if err == nil {
+		t.Fatal("expected decode error")
+	}
+}
+
+func TestDispatchClient_Status_Success(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			writeError(w, http.StatusMethodNotAllowed, "method")
+			return
+		}
+		body, _ := io.ReadAll(r.Body)
+		var req StatusRequest
+		_ = json.Unmarshal(body, &req)
+		if req.JobID != "job-9" {
+			writeError(w, http.StatusBadRequest, "bad job_id")
+			return
+		}
+		writeJSON(w, http.StatusOK, StatusResponse{JobID: "job-9", NodeID: "self", State: "complete"})
+	}))
+	defer srv.Close()
+
+	dc := &DispatchClient{
+		HTTP:     &MTLSClient{http: &http.Client{Timeout: 5 * time.Second}},
+		PeerAddr: srv.URL,
+	}
+	resp, err := dc.Status(context.Background(), "job-9")
+	if err != nil {
+		t.Fatalf("Status: %v", err)
+	}
+	if resp.JobID != "job-9" {
+		t.Errorf("JobID = %q, want job-9", resp.JobID)
+	}
+	if resp.State != "complete" {
+		t.Errorf("State = %q, want complete", resp.State)
+	}
+}
+
+func TestDispatchClient_Submit_Success(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			writeError(w, http.StatusMethodNotAllowed, "method")
+			return
+		}
+		writeJSON(w, http.StatusOK, SubmitResponse{JobID: "job-submit-1", NodeID: "peer-1"})
+	}))
+	defer srv.Close()
+
+	dc := &DispatchClient{
+		HTTP:     &MTLSClient{http: &http.Client{Timeout: 5 * time.Second}},
+		PeerAddr: srv.URL,
+	}
+	resp, err := dc.Submit(context.Background(), []byte("spec"), "idem-key-1")
+	if err != nil {
+		t.Fatalf("Submit: %v", err)
+	}
+	if resp.JobID != "job-submit-1" {
+		t.Errorf("JobID = %q, want job-submit-1", resp.JobID)
+	}
+}
+
+func TestDispatchClient_Submit_NonIdempotentTransientBails(t *testing.T) {
+	calls := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls++
+		writeError(w, http.StatusServiceUnavailable, "unavailable")
+	}))
+	defer srv.Close()
+
+	dc := &DispatchClient{
+		HTTP:     &MTLSClient{http: &http.Client{Timeout: 5 * time.Second}},
+		PeerAddr: srv.URL,
+	}
+	_, err := dc.Submit(context.Background(), []byte("spec"), "")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if calls != 1 {
+		t.Errorf("calls = %d, want 1 (no key, no retry)", calls)
+	}
+}
+
+func TestBytesReader(t *testing.T) {
+	r := bytesReader([]byte("hello"))
+	buf := make([]byte, 5)
+	n, err := r.Read(buf)
+	if n != 5 || err != nil || string(buf) != "hello" {
+		t.Errorf("Read: n=%d err=%v buf=%q", n, err, buf)
+	}
+	n, err = r.Read(buf)
+	if n != 0 || err == nil {
+		t.Errorf("Read past end: n=%d err=%v, want error", n, err)
+	}
+	if err := r.Close(); err != nil {
+		t.Errorf("Close: %v", err)
+	}
+}

internal/transport/handshake_log_test.go

@@ -0,0 +1,100 @@
+package transport
+
+import (
+	"bytes"
+	"errors"
+	"log/slog"
+	"strings"
+	"testing"
+)
+
+func newTestLogger(buf *bytes.Buffer) *slog.Logger {
+	return slog.New(slog.NewTextHandler(buf, nil))
+}
+
+func TestLogHandshakeOK(t *testing.T) {
+	var buf bytes.Buffer
+	log := newTestLogger(&buf)
+	LogHandshakeOK(log, "peer1", "fp123")
+	out := buf.String()
+	for _, want := range []string{
+		"event=mtls.handshake",
+		"result=ok",
+		"peer=peer1",
+		"cert_fp=fp123",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("output missing %q: %s", want, out)
+		}
+	}
+}
+
+func TestLogHandshakeFailed(t *testing.T) {
+	var buf bytes.Buffer
+	log := newTestLogger(&buf)
+	LogHandshakeFailed(log, "peer1", "", errors.New("tls: bad cert"))
+	out := buf.String()
+	for _, want := range []string{
+		"event=mtls.handshake",
+		"result=failed",
+		"peer=peer1",
+		"err=\"tls: bad cert\"",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("output missing %q: %s", want, out)
+		}
+	}
+	if !strings.Contains(out, "level=WARN") {
+		t.Errorf("expected WARN level, got: %s", out)
+	}
+}
+
+func TestLogHandshakeOK_NilLogger(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("nil logger panicked: %v", r)
+		}
+	}()
+	LogHandshakeOK(nil, "peer1", "fp123")
+}
+
+func TestLogHandshakeFailed_NilLogger(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("nil logger panicked: %v", r)
+		}
+	}()
+	LogHandshakeFailed(nil, "peer1", "", errors.New("x"))
+}
+
+func TestLogHandshakeFailed_NoErr(t *testing.T) {
+	var buf bytes.Buffer
+	log := newTestLogger(&buf)
+	LogHandshakeFailed(log, "peer1", "fp123", nil)
+	out := buf.String()
+	if strings.Contains(out, "err=") {
+		t.Errorf("expected no err= field when err is nil: %s", out)
+	}
+	if !strings.Contains(out, "result=failed") {
+		t.Errorf("expected result=failed: %s", out)
+	}
+}
+
+func TestLogHandshakeFromCert_NilCert(t *testing.T) {
+	var buf bytes.Buffer
+	log := newTestLogger(&buf)
+	LogHandshakeFromCert(log, "peer1", nil)
+	out := buf.String()
+	if !strings.Contains(out, "result=ok") {
+		t.Errorf("expected result=ok: %s", out)
+	}
+	if !strings.Contains(out, "peer=peer1") {
+		t.Errorf("expected peer=peer1: %s", out)
+	}
+}
+
+func TestFingerprintOfCert_Nil(t *testing.T) {
+	if got := FingerprintOfCert(nil); got != "" {
+		t.Errorf("FingerprintOfCert(nil) = %q, want empty", got)
+	}
+}

internal/transport/mtls_test.go

@@ -0,0 +1,223 @@
+package transport
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/pem"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"git.cloudinit.dev/coreci/orca/internal/security"
+)
+
+func generateTestCerts(t *testing.T, dir, serverName string) (certPath, keyPath, caPath string) {
+	t.Helper()
+	ca, err := security.CAInit(dir, "orca-test-ca")
+	if err != nil {
+		t.Fatalf("CAInit: %v", err)
+	}
+	keyPEM, csrPEM, err := security.GenerateCSR(serverName, []string{serverName, "127.0.0.1"})
+	if err != nil {
+		t.Fatalf("GenerateCSR: %v", err)
+	}
+	signedPEM, err := ca.SignCSR(csrPEM)
+	if err != nil {
+		t.Fatalf("SignCSR: %v", err)
+	}
+	certPath = filepath.Join(dir, "server.crt")
+	keyPath = filepath.Join(dir, "server.key")
+	caPath = filepath.Join(dir, security.CACertFile)
+	if err := os.WriteFile(certPath, signedPEM, 0o644); err != nil {
+		t.Fatalf("write cert: %v", err)
+	}
+	if err := os.WriteFile(keyPath, keyPEM, 0o600); err != nil {
+		t.Fatalf("write key: %v", err)
+	}
+	return certPath, keyPath, caPath
+}
+
+func TestServerTLSConfig(t *testing.T) {
+	dir := t.TempDir()
+	certPath, keyPath, caPath := generateTestCerts(t, dir, "localhost")
+	cfg, err := security.ServerTLSConfig(certPath, keyPath, caPath)
+	if err != nil {
+		t.Fatalf("ServerTLSConfig: %v", err)
+	}
+	if cfg.MinVersion != tls.VersionTLS13 {
+		t.Errorf("MinVersion = %d, want %d", cfg.MinVersion, tls.VersionTLS13)
+	}
+	if cfg.MaxVersion != tls.VersionTLS13 {
+		t.Errorf("MaxVersion = %d, want %d", cfg.MaxVersion, tls.VersionTLS13)
+	}
+	if cfg.ClientAuth != tls.RequireAndVerifyClientCert {
+		t.Errorf("ClientAuth = %v, want RequireAndVerifyClientCert", cfg.ClientAuth)
+	}
+	if cfg.ClientCAs == nil {
+		t.Error("ClientCAs is nil")
+	}
+	if len(cfg.CipherSuites) == 0 {
+		t.Error("CipherSuites is empty")
+	}
+}
+
+func TestServerTLSConfig_MissingFiles(t *testing.T) {
+	dir := t.TempDir()
+	_, err := security.ServerTLSConfig(
+		filepath.Join(dir, "nope.crt"),
+		filepath.Join(dir, "nope.key"),
+		filepath.Join(dir, "nope.ca"),
+	)
+	if err == nil {
+		t.Fatal("expected error for missing files")
+	}
+}
+
+func TestClientTLSConfig(t *testing.T) {
+	dir := t.TempDir()
+	certPath, keyPath, caPath := generateTestCerts(t, dir, "localhost")
+	cfg, err := security.ClientTLSConfig(caPath, "localhost", certPath, keyPath)
+	if err != nil {
+		t.Fatalf("ClientTLSConfig: %v", err)
+	}
+	if cfg.MinVersion != tls.VersionTLS13 {
+		t.Errorf("MinVersion = %d, want %d", cfg.MinVersion, tls.VersionTLS13)
+	}
+	if cfg.RootCAs == nil {
+		t.Error("RootCAs is nil")
+	}
+	if cfg.ServerName != "localhost" {
+		t.Errorf("ServerName = %q, want localhost", cfg.ServerName)
+	}
+	if len(cfg.Certificates) != 1 {
+		t.Errorf("Certificates len = %d, want 1", len(cfg.Certificates))
+	}
+}
+
+func TestClientTLSConfig_NoClientCert(t *testing.T) {
+	dir := t.TempDir()
+	_, _, caPath := generateTestCerts(t, dir, "localhost")
+	cfg, err := security.ClientTLSConfig(caPath, "localhost", "", "")
+	if err != nil {
+		t.Fatalf("ClientTLSConfig: %v", err)
+	}
+	if len(cfg.Certificates) != 0 {
+		t.Errorf("Certificates len = %d, want 0", len(cfg.Certificates))
+	}
+}
+
+func TestClientTLSConfig_MismatchedCertKey(t *testing.T) {
+	dir := t.TempDir()
+	_, _, caPath := generateTestCerts(t, dir, "localhost")
+	if _, err := security.ClientTLSConfig(caPath, "localhost", "only-cert", ""); err == nil {
+		t.Error("expected error for cert without key")
+	}
+	if _, err := security.ClientTLSConfig(caPath, "localhost", "", "only-key"); err == nil {
+		t.Error("expected error for key without cert")
+	}
+}
+
+func TestNewMTLSClient(t *testing.T) {
+	dir := t.TempDir()
+	_, _, caPath := generateTestCerts(t, dir, "localhost")
+	c, err := NewMTLSClient(caPath, "localhost", "", "")
+	if err != nil {
+		t.Fatalf("NewMTLSClient: %v", err)
+	}
+	if c == nil {
+		t.Fatal("client is nil")
+	}
+}
+
+func TestNewMTLSClient_EmptyCAPath(t *testing.T) {
+	_, err := NewMTLSClient("", "localhost", "", "")
+	if err == nil {
+		t.Fatal("expected error for empty caPath")
+	}
+}
+
+func TestNewMTLSClient_EmptyServerName(t *testing.T) {
+	dir := t.TempDir()
+	_, _, caPath := generateTestCerts(t, dir, "localhost")
+	_, err := NewMTLSClient(caPath, "", "", "")
+	if err == nil {
+		t.Fatal("expected error for empty serverName")
+	}
+}
+
+func TestNewMTLSClient_MissingCAFile(t *testing.T) {
+	_, err := NewMTLSClient("/nonexistent/ca.crt", "localhost", "", "")
+	if err == nil {
+		t.Fatal("expected error for missing CA file")
+	}
+}
+
+func TestMTLSClient_Do_NilReceiver(t *testing.T) {
+	var c *MTLSClient
+	_, err := c.Do(nil)
+	if err == nil {
+		t.Fatal("expected error for nil receiver")
+	}
+}
+
+func TestVerifyPeerCertificate_NoCerts(t *testing.T) {
+	cb := VerifyPeerCertificate("expected")
+	if err := cb(nil, nil); err == nil {
+		t.Error("expected error for no peer certs")
+	}
+}
+
+func TestVerifyPeerCertificate_Mismatch(t *testing.T) {
+	dir := t.TempDir()
+	certPath, _, _ := generateTestCerts(t, dir, "localhost")
+	certPEM, err := os.ReadFile(certPath)
+	if err != nil {
+		t.Fatalf("read cert: %v", err)
+	}
+	block, _ := pem.Decode(certPEM)
+	if block == nil {
+		t.Fatal("pem.Decode: no cert block")
+	}
+	cb := VerifyPeerCertificate("wrong-fingerprint")
+	if err := cb([][]byte{block.Bytes}, nil); err == nil {
+		t.Error("expected error for fingerprint mismatch")
+	}
+}
+
+func TestVerifyPeerCertificate_Match(t *testing.T) {
+	dir := t.TempDir()
+	certPath, _, _ := generateTestCerts(t, dir, "localhost")
+	certPEM, err := os.ReadFile(certPath)
+	if err != nil {
+		t.Fatalf("read cert: %v", err)
+	}
+	block, _ := pem.Decode(certPEM)
+	if block == nil {
+		t.Fatal("pem.Decode: no cert block")
+	}
+	leaf, err := x509.ParseCertificate(block.Bytes)
+	if err != nil {
+		t.Fatalf("ParseCertificate: %v", err)
+	}
+	expected := security.FingerprintOf(leaf.Raw)
+	cb := VerifyPeerCertificate(expected)
+	if err := cb([][]byte{block.Bytes}, nil); err != nil {
+		t.Errorf("expected match, got: %v", err)
+	}
+}
+
+func TestDialContext_EmptyCAPath(t *testing.T) {
+	_, err := DialContext(t.Context(), "tcp", "127.0.0.1:0", "", "localhost")
+	if err == nil {
+		t.Fatal("expected error for empty caPath")
+	}
+}
+
+func TestDialContext_ConnectionRefused(t *testing.T) {
+	dir := t.TempDir()
+	_, _, caPath := generateTestCerts(t, dir, "localhost")
+	_, err := DialContext(t.Context(), "tcp", "127.0.0.1:1", caPath, "localhost")
+	if err == nil {
+		t.Fatal("expected error for connection refused")
+	}
+}