feat: Phase 0 of hexagonal refactor — ADR 0016, core scaffold, depguard rules

Problem: the hexagonal-architecture plan (plans/2026-08-15-hexagonal-
architecture.md) needs its foundation — an accepted ADR, the target
directory tree, and machine-checked dependency rules — before any
service extraction starts. Also folds the four outstanding review
findings (F3.1/F5/F6/F7) into the plan: ObservationService owns the
bounded probe-concurrency contract (scheduler.go:133), Phase 9 gates
ExecutionService+PolicyService ≥ 90% with a gating-matrix test,
per-phase abort criteria, and the §3.2 internal/config note.

Change:
- docs/adr/0016-hexagonal-ports-adapters.md records context, decision,
  and consequences of the ports & adapters migration.
- internal/domain → internal/core/domain (mechanical import rewrite,
  20 files), new internal/core/{ports,app}, internal/adapters trees
  with package docs.
- .golangci.yml: depguard rules for §3.1 (core purity, no agent-client
  tech in core, nomos isolation — the nomos rules self-activate when
  internal/nomos exists in Phase 8). Config migrated to golangci-lint
  v2 format so it loads at all (the v1 config errored under v2, masked
  by CI's advisory continue-on-error). Verified depguard fires on a
  planted openai-go import in internal/core/app.
- CONTRIBUTING.md layout section now shows the core/adapters tree.

Risk: import path churn is mechanical and tests pass unchanged; the
lint config migration surfaces the pre-existing 400-issue baseline
(advisory in CI, unchanged policy) — new/moved packages lint clean.

Verification: go vet ./..., make test (race, core/domain at 100%
coverage), make generate-check, golangci-lint on internal/core/... and
internal/adapters/... — 0 issues; depguard violation probe confirmed.

internal/core/domain/entity.go

@@ -0,0 +1,76 @@
+package domain
+
+import (
+	"time"
+)
+
+// Entity is the core graph node — every object in the OS is an entity.
+// Typed tables (signals, executions, etc.) reference entities(id) for
+// indexed querying; graph edges live in the relationships table.
+type Entity struct {
+	ID              UUID
+	Slug            string
+	Type            string
+	Name            string
+	State           string
+	Attributes      map[string]any
+	MaintenanceUntil *time.Time
+	Version         int
+	CreatedAt       time.Time
+	UpdatedAt       time.Time
+}
+
+// EntityType is the meta-schema entry defining what entities can exist.
+type EntityType struct {
+	Name            string
+	ParentType      string
+	IsAbstract      bool
+	Domain          string
+	Layer           string
+	Description     string
+	LifecycleID     string
+	AttributeSchema map[string]any
+	SchemaVersion   int
+	Status          string
+}
+
+// RelationshipType defines a typed edge between entity types.
+type RelationshipType struct {
+	Name        string
+	Inverse     string
+	SourceType  string
+	TargetType  string
+	Cardinality string
+	Description string
+}
+
+// LifecycleDef is the state machine for an entity type.
+type LifecycleDef struct {
+	ID             string
+	States         []string
+	DefaultState   string
+	TerminalStates []string
+	Transitions    map[string]map[string]TransitionReq
+}
+
+// TransitionReq holds the named preconditions for a lifecycle transition.
+type TransitionReq struct {
+	Requires []string `json:"requires"`
+}
+
+// Relationship is a typed edge between two entities.
+type Relationship struct {
+	SourceID   UUID
+	TargetID   UUID
+	Type       string
+	Attributes map[string]any
+	ValidFrom  time.Time
+	ValidTo    *time.Time
+}
+
+// UUID is a type alias for UUID values. Using string for simplicity;
+// the DB layer uses pgx's UUID type. Conversion happens at the boundary.
+type UUID string
+
+// IsNil returns true if the UUID is empty.
+func (u UUID) IsNil() bool { return u == "" }