feat: Phase 2 — ports package, secrets port move, postgres adapter move

Problem: the hexagon's Phase 2 (plans/2026-08-15-hexagonal-architecture.md)
must give the use-cases-to-be their contract surface: driven-port
interfaces, test fakes, the secrets interface moved into core, and the
postgres package inside the adapters tree — before the first vertical
slice (Phase 3) can wire a composition root.

Change:
- internal/core/ports: full driven-port catalog per plan §3.3 —
  repositories as transaction-scoped aggregates whose inputs carry
  derived checks, audit, and events (§3.6), plus CommandExecutor,
  TargetResolver, Checker, Secrets, EventPublisher, Provisioner.
  Port-local payload types (Event, AuditEntry, CheckDef, KnowledgeEntry,
  ExecResult) keep signatures off infrastructure; TypeTree aliases
  internal/ontology (pure over domain) until checkdefaults is absorbed.
  ReadModels intentionally not declared yet — it materializes with the
  Phase 3 slice and grows as report handlers rewire.
- secrets.Backend is now an alias of ports.Secrets; implementations
  (Infisical, SOPS, Manager) unchanged. mcp's local secretBackend
  subset is deleted; tool constructors take ports.Secrets.
- internal/db → internal/adapters/postgres (mechanical import rewrite;
  package identifier stays db until the Phase 3 repository split).
  sqlc.yaml, Makefile, golangci exclusions, and docs follow the move;
  make generate-check verified.
- internal/adapters/ssh: Executor implements ports.CommandExecutor over
  the actuator dial pool + RunStreaming (10-min default timeout carried
  over from the httpapi path).
- internal/adapters/remote: Resolver implements ports.TargetResolver
  delegating to internal/remote (still pool-based; drops onto
  ports.EntityRepository when repositories land in Phase 3 — documented
  transitional import).
- internal/core/ports/portstest: importable fakes — in-memory
  EntityRepo (with check-then-act SetState, side-effect recording),
  RecordingExecutor, FakeChecker, SpyPublisher; port-satisfaction
  guards; tests.

Risk: ports are declared ahead of implementations — signatures firm up
per phase as slices land (documented in the package doc); the
remote→postgres transitional import is explicit and dissolves in
Phase 3.

Verification: go vet, make test (race, 19 packages), generate-check,
golangci on core+adapters — 0 issues; full-repo baseline down
365→344.

internal/core/ports/execution.go

@@ -0,0 +1,74 @@
+package ports
+
+import (
+	"context"
+	"time"
+
+	"github.com/dtoro/oikos/internal/core/domain"
+)
+
+// Target is a resolved execution endpoint (mirrors remote.ExecTarget; the
+// remote adapter maps between them). Wrap rewrites a plain command for
+// transport: identity for a host, pct/qm wrapping for guests.
+type Target struct {
+	Host string
+	User string
+	Wrap func(cmd string) string
+}
+
+// ExecOpts carries execution options; Sink, when non-nil, receives output
+// chunks as they arrive (streaming path).
+type ExecOpts struct {
+	Timeout time.Duration
+	Sink    func(stream string, chunk []byte)
+}
+
+// ExecResult is the outcome of one command execution.
+type ExecResult struct {
+	Output   string
+	Duration time.Duration
+	Err      error
+}
+
+// CommandExecutor runs a command on a resolved target over SSH. Implemented
+// by the ssh adapter wrapping internal/actuator (dial pool + breaker).
+type CommandExecutor interface {
+	Run(ctx context.Context, target Target, command string, opts ExecOpts) ExecResult
+}
+
+// TargetResolver resolves entity slugs/IDs to execution endpoints.
+// Implemented by the remote adapter on top of EntityRepository.
+type TargetResolver interface {
+	ResolveExecTarget(ctx context.Context, targetSlug string) (Target, error)
+	ResolveForCheck(ctx context.Context, targetID domain.UUID, targetType string) (Target, error)
+	ResolveHost(ctx context.Context, hostSlug, fallbackUser string) (addr, user string, err error)
+	// IsGuest reports whether an entity type is reached via pct/qm exec
+	// through a Proxmox host rather than by direct SSH.
+	IsGuest(entityType string) bool
+}
+
+// Provisioner creates guests via pct/qm on a Proxmox host (Phase 7 fills
+// the input payloads in; signatures firm up with ProvisioningService).
+type Provisioner interface {
+	CreateLXC(ctx context.Context, host domain.UUID, input LXCInput) (domain.UUID, error)
+	CreateVM(ctx context.Context, host domain.UUID, input VMInput) (domain.UUID, error)
+}
+
+// LXCInput is a placeholder until ProvisioningService (Phase 7) fixes the
+// create payloads; declared now so the port surface is complete.
+type LXCInput struct {
+	Name     string
+	Template string
+	Cores    int
+	MemoryMB int
+	DiskGB   int
+}
+
+// VMInput mirrors LXCInput for VM creation via qm.
+type VMInput struct {
+	Name       string
+	TemplateID int
+	Cores      int
+	MemoryMB   int
+	DiskGB     int
+}