Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

62.5 KB
Raw Blame
package repoctl

import (
	"encoding/json"
	"errors"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"slices"
	"strings"
	"testing"
)

func useStagedGovernanceReads() bool {
	return os.Getenv("PULSE_READ_STAGED_GOVERNANCE") == "1"
}

func repoRootPath(t *testing.T) string {
	t.Helper()

	root, err := filepath.Abs(filepath.Join("..", ".."))
	if err != nil {
		t.Fatalf("failed to resolve pulse repo root: %v", err)
	}
	return root
}

func readRepoFile(t *testing.T, rel string) string {
	t.Helper()

	if useStagedGovernanceReads() {
		cmd := exec.Command("git", "show", ":"+rel)
		cmd.Dir = repoRootPath(t)
		data, err := cmd.Output()
		if err != nil {
			// Governance files live in internal/ and are not tracked in the public repo.
			// Skip gracefully so the test suite passes on a fresh clone.
			t.Skipf("governance file not available in this checkout: %s", rel)
		}
		return string(data)
	}

	path := filepath.Join("..", "..", rel)
	data, err := os.ReadFile(path)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			// Governance files live in internal/ and are not tracked in the public repo.
			// Skip gracefully so the test suite passes on a fresh clone.
			t.Skipf("governance file not present in this checkout: %s", rel)
		}
		t.Fatalf("failed to read %s: %v", rel, err)
	}
	return string(data)
}

func assertContainsAll(t *testing.T, rel string, content string, required []string) {
	t.Helper()
	for _, item := range required {
		if !strings.Contains(content, item) {
			t.Fatalf("%s missing required content %q", rel, item)
		}
	}
}

func assertContainsNone(t *testing.T, rel string, content string, forbidden []string) {
	t.Helper()
	for _, item := range forbidden {
		if strings.Contains(content, item) {
			t.Fatalf("%s contains retired content %q", rel, item)
		}
	}
}

func assertRepoFileMissing(t *testing.T, rel string) {
	t.Helper()

	if useStagedGovernanceReads() {
		cmd := exec.Command("git", "cat-file", "-e", ":"+rel)
		cmd.Dir = repoRootPath(t)
		err := cmd.Run()
		if err == nil {
			t.Fatalf("%s should be removed from the staged commit", rel)
		}
		var exitErr *exec.ExitError
		if !errors.As(err, &exitErr) {
			t.Fatalf("failed to inspect staged %s: %v", rel, err)
		}
		return
	}

	path := filepath.Join("..", "..", rel)
	_, err := os.Stat(path)
	if err == nil {
		t.Fatalf("%s should be removed", rel)
	}
	if !os.IsNotExist(err) {
		t.Fatalf("failed to stat %s: %v", rel, err)
	}
}

func sourceOfTruthLastUpdated(t *testing.T, content string) string {
	t.Helper()

	re := regexp.MustCompile(`(?m)^Last updated: ([0-9]{4}-[0-9]{2}-[0-9]{2})$`)
	match := re.FindStringSubmatch(content)
	if len(match) != 2 {
		t.Fatalf("SOURCE_OF_TRUTH.md missing parsable Last updated line")
	}
	return match[1]
}

func statusJSON(t *testing.T) map[string]any {
	t.Helper()

	content := readRepoFile(t, "docs/release-control/v6/internal/status.json")
	var payload map[string]any
	if err := json.Unmarshal([]byte(content), &payload); err != nil {
		t.Fatalf("failed to parse status.json: %v", err)
	}
	return payload
}

func statusLaneIDs(t *testing.T, status map[string]any) map[string]struct{} {
	t.Helper()

	rawLanes, ok := status["lanes"].([]any)
	if !ok {
		t.Fatalf("status.json missing lanes list")
	}

	ids := make(map[string]struct{}, len(rawLanes))
	for _, rawLane := range rawLanes {
		lane, ok := rawLane.(map[string]any)
		if !ok {
			t.Fatalf("status.json lanes contains non-object entry")
		}
		id, ok := lane["id"].(string)
		if !ok || id == "" {
			t.Fatalf("status.json lane missing id")
		}
		ids[id] = struct{}{}
	}
	return ids
}

func repoRootForEvidence(t *testing.T, repo string) string {
	t.Helper()

	envKey := "PULSE_REPO_ROOT_" + strings.ToUpper(strings.ReplaceAll(repo, "-", "_"))
	if value := os.Getenv(envKey); value != "" {
		return value
	}

	currentRoot, err := filepath.Abs(filepath.Join("..", ".."))
	if err != nil {
		t.Fatalf("failed to resolve pulse repo root: %v", err)
	}
	commonDir, err := gitCommonDir(currentRoot)
	if err != nil {
		return repoRootForEvidenceFromGitLayout(repo, currentRoot, "")
	}
	return repoRootForEvidenceFromGitLayout(repo, currentRoot, commonDir)
}

func gitCommonDir(repoRoot string) (string, error) {
	cmd := exec.Command("git", "rev-parse", "--path-format=absolute", "--git-common-dir")
	cmd.Dir = repoRoot
	data, err := cmd.Output()
	if err != nil {
		return "", err
	}
	commonDir := strings.TrimSpace(string(data))
	if commonDir == "" {
		return "", nil
	}
	if !filepath.IsAbs(commonDir) {
		commonDir = filepath.Join(repoRoot, commonDir)
	}
	return filepath.Clean(commonDir), nil
}

func repoRootForEvidenceFromGitLayout(repo string, currentRoot string, commonDir string) string {
	currentRoot = filepath.Clean(currentRoot)
	if repo == "pulse" {
		return currentRoot
	}
	pulseRoot := canonicalPulseRootFromGitCommonDir(currentRoot, commonDir)
	return filepath.Join(filepath.Dir(pulseRoot), repo)
}

func canonicalPulseRootFromGitCommonDir(currentRoot string, commonDir string) string {
	if commonDir == "" {
		return filepath.Clean(currentRoot)
	}
	commonDir = filepath.Clean(commonDir)
	if filepath.Base(commonDir) != ".git" {
		return filepath.Clean(currentRoot)
	}
	return filepath.Dir(commonDir)
}

func TestRepoRootForEvidenceDerivesCanonicalSiblingRootFromLinkedWorktree(t *testing.T) {
	workspace := filepath.Join(string(filepath.Separator), "Volumes", "Development", "pulse")
	currentRoot := filepath.Join(workspace, ".worktrees", "pulse-precommit-worktree-compatibility-sweep")
	commonDir := filepath.Join(workspace, "repos", "pulse", ".git")

	got := repoRootForEvidenceFromGitLayout("pulse-pro", currentRoot, commonDir)
	want := filepath.Join(workspace, "repos", "pulse-pro")
	if got != want {
		t.Fatalf("pulse-pro evidence root = %q, want %q", got, want)
	}
	if strings.Contains(got, string(filepath.Separator)+".worktrees"+string(filepath.Separator)) {
		t.Fatalf("sibling evidence root must not be derived under .worktrees: %q", got)
	}
}

func TestRepoRootForEvidenceKeepsPulseEvidenceOnCurrentWorktree(t *testing.T) {
	workspace := filepath.Join(string(filepath.Separator), "Volumes", "Development", "pulse")
	currentRoot := filepath.Join(workspace, ".worktrees", "pulse-precommit-worktree-compatibility-sweep")
	commonDir := filepath.Join(workspace, "repos", "pulse", ".git")

	got := repoRootForEvidenceFromGitLayout("pulse", currentRoot, commonDir)
	if got != currentRoot {
		t.Fatalf("pulse evidence root = %q, want current worktree %q", got, currentRoot)
	}
}

func TestRepoRootForEvidenceHonorsEnvOverride(t *testing.T) {
	overrideRoot := filepath.Join(t.TempDir(), "custom-pulse-pro")
	t.Setenv("PULSE_REPO_ROOT_PULSE_PRO", overrideRoot)

	if got := repoRootForEvidence(t, "pulse-pro"); got != overrideRoot {
		t.Fatalf("pulse-pro evidence root = %q, want override %q", got, overrideRoot)
	}
}

func shouldSkipCrossRepoEvidenceExistenceCheck(repo string) bool {
	if repo == "pulse" {
		return false
	}
	if os.Getenv("GITHUB_ACTIONS") != "true" {
		return false
	}
	envKey := "PULSE_REPO_ROOT_" + strings.ToUpper(strings.ReplaceAll(repo, "-", "_"))
	return os.Getenv(envKey) == ""
}

func validateEvidenceRefs(t *testing.T, activeRepos map[string]struct{}, allowedKinds []string, rawEvidence []any, context string) {
	t.Helper()

	for _, rawEvidenceRef := range rawEvidence {
		ref, ok := rawEvidenceRef.(map[string]any)
		if !ok {
			t.Fatalf("%s contains legacy non-object evidence entry", context)
		}

		repo, ok := ref["repo"].(string)
		if !ok || repo == "" {
			t.Fatalf("%s evidence missing repo", context)
		}
		if _, ok := activeRepos[repo]; !ok {
			t.Fatalf("%s evidence repo %q is not in active_repos", context, repo)
		}

		path, ok := ref["path"].(string)
		if !ok || path == "" {
			t.Fatalf("%s evidence missing path", context)
		}
		if filepath.IsAbs(path) {
			t.Fatalf("%s evidence path %q must not be absolute", context, path)
		}
		cleaned := filepath.ToSlash(filepath.Clean(path))
		if cleaned != path {
			t.Fatalf("%s evidence path %q must be clean relative path %q", context, path, cleaned)
		}
		if strings.HasPrefix(path, "../") || strings.Contains(path, "/../") {
			t.Fatalf("%s evidence path %q must not escape repo root", context, path)
		}

		kind, ok := ref["kind"].(string)
		if !ok || !slices.Contains(allowedKinds, kind) {
			t.Fatalf("%s evidence kind %#v not allowed", context, ref["kind"])
		}

		repoRoot := repoRootForEvidence(t, repo)
		if info, err := os.Stat(repoRoot); err != nil || !info.IsDir() {
			if shouldSkipCrossRepoEvidenceExistenceCheck(repo) {
				t.Logf("%s evidence repo %q not present in this CI checkout; skipping existence check", context, repo)
				continue
			}
			t.Fatalf("%s evidence repo root for %q missing at %q (set %s to override): %v", context, repo, repoRoot, "PULSE_REPO_ROOT_"+strings.ToUpper(strings.ReplaceAll(repo, "-", "_")), err)
		}

		fullPath := filepath.Join(repoRoot, path)
		info, err := os.Stat(fullPath)
		if err != nil {
			t.Fatalf("%s evidence path %q missing in repo %q: %v", context, path, repo, err)
		}
		switch kind {
		case "file":
			if !info.Mode().IsRegular() {
				t.Fatalf("%s evidence path %q in repo %q should be file", context, path, repo)
			}
		case "dir":
			if !info.IsDir() {
				t.Fatalf("%s evidence path %q in repo %q should be dir", context, path, repo)
			}
		}
	}
}

func validateProofCommands(t *testing.T, rawProofCommands any, context string) int {
	t.Helper()

	commands, ok := rawProofCommands.([]any)
	if !ok || len(commands) == 0 {
		t.Fatalf("%s missing proof_commands list", context)
	}

	seenIDs := make(map[string]struct{}, len(commands))
	ids := make([]string, 0, len(commands))
	for _, rawCommand := range commands {
		command, ok := rawCommand.(map[string]any)
		if !ok {
			t.Fatalf("%s proof_commands contains non-object entry", context)
		}

		id, ok := command["id"].(string)
		if !ok || strings.TrimSpace(id) == "" {
			t.Fatalf("%s proof_commands contains command without id", context)
		}
		if _, exists := seenIDs[id]; exists {
			t.Fatalf("%s proof_commands duplicates id %q", context, id)
		}
		seenIDs[id] = struct{}{}
		ids = append(ids, id)

		rawRun, ok := command["run"].([]any)
		if !ok || len(rawRun) == 0 {
			t.Fatalf("%s proof_command %q missing run list", context, id)
		}
		for _, rawArg := range rawRun {
			arg, ok := rawArg.(string)
			if !ok || strings.TrimSpace(arg) == "" {
				t.Fatalf("%s proof_command %q run contains invalid entry", context, id)
			}
		}

		if rawCwd, ok := command["cwd"]; ok {
			cwd, ok := rawCwd.(string)
			if !ok || strings.TrimSpace(cwd) == "" {
				t.Fatalf("%s proof_command %q has invalid cwd %#v", context, id, rawCwd)
			}
			if filepath.IsAbs(cwd) {
				t.Fatalf("%s proof_command %q cwd %q must not be absolute", context, id, cwd)
			}
			cleaned := filepath.ToSlash(filepath.Clean(cwd))
			if cleaned != cwd || strings.HasPrefix(cwd, "../") || strings.Contains(cwd, "/../") {
				t.Fatalf("%s proof_command %q cwd %q must be clean relative path", context, id, cwd)
			}
		}
	}

	sortedIDs := slices.Clone(ids)
	slices.Sort(sortedIDs)
	if !slices.Equal(ids, sortedIDs) {
		t.Fatalf("%s proof_commands must be sorted by command id", context)
	}

	return len(commands)
}

func TestCanonicalDevelopmentProtocolExists(t *testing.T) {
	rel := "docs/release-control/v6/internal/CANONICAL_DEVELOPMENT_PROTOCOL.md"
	content := readRepoFile(t, rel)
	assertContainsAll(t, rel, content, []string{
		"# Pulse v6 Canonical Development Protocol",
		"AGENT_VALUES.md",
		"control_plane.py --agent-entrypoint --pretty",
		"status_lookup.py",
		"work_claim.py",
		"status.json",
	})
}

func TestSubsystemContractsExistWithRequiredSections(t *testing.T) {
	requiredContracts := []string{
		"docs/release-control/v6/internal/subsystems/alerts.md",
		"docs/release-control/v6/internal/subsystems/api-contracts.md",
		"docs/release-control/v6/internal/subsystems/cloud-paid.md",
		"docs/release-control/v6/internal/subsystems/frontend-primitives.md",
		"docs/release-control/v6/internal/subsystems/monitoring.md",
		"docs/release-control/v6/internal/subsystems/organization-settings.md",
		"docs/release-control/v6/internal/subsystems/patrol-intelligence.md",
		"docs/release-control/v6/internal/subsystems/performance-and-scalability.md",
		"docs/release-control/v6/internal/subsystems/unified-resources.md",
	}

	requiredSections := []string{
		"## Contract Metadata",
		"## Purpose",
		"## Canonical Files",
		"## Shared Boundaries",
		"## Extension Points",
		"## Forbidden Paths",
		"## Completion Obligations",
		"## Current State",
	}

	for _, rel := range requiredContracts {
		content := readRepoFile(t, rel)
		assertContainsAll(t, rel, content, requiredSections)
	}
}

func TestSubsystemRegistryExistsAndReferencesContracts(t *testing.T) {
	rel := "docs/release-control/v6/internal/subsystems/registry.json"
	content := readRepoFile(t, rel)
	assertContainsAll(t, rel, content, []string{
		"\"version\": 13",
		"\"shared_ownerships\":",
		"\"subsystems\":",
		"\"verification\":",
		"\"allow_same_subsystem_tests\":",
		"\"test_prefixes\":",
		"\"exact_files\":",
		"\"path_policies\":",
		"\"require_explicit_path_policy_coverage\":",
		"pkg/licensing/evaluator.go",
		"pkg/licensing/token_source.go",
		"pkg/licensing/entitlement_payload.go",
		"pkg/licensing/hosted_subscription.go",
		"pkg/licensing/billing_state_normalization.go",
		"pkg/licensing/database_source.go",
		"pkg/licensing/features.go",
		"pkg/licensing/stripe_subscription.go",
		"pkg/licensing/models.go",
		"pkg/licensing/activation_types.go",
		"pkg/licensing/service.go",
		"pkg/licensing/grant_refresh.go",
		"pkg/licensing/installation_status_poll.go",
		"pkg/licensing/license_server_client.go",
		"pkg/licensing/persistence.go",
		"pkg/licensing/activation_store.go",
		"pkg/licensing/trial_activation.go",
		"pkg/licensing/public_key.go",
		"pkg/licensing/trial_start.go",
		"internal/api/licensing_",
		"internal/api/payments_",
		"internal/cloudcp/entitlements/service.go",
		"internal/cloudcp/registry/registry.go",
		"internal/cloudcp/stripe/provisioner.go",
		"pulse-pro:license-server/admin_ui.go",
		"pulse-pro:license-server/v6_grants.go",
		"pulse-pro:license-server/v6_handlers.go",
		"pulse-pro:license-server/v6_store.go",
		"docs/release-control/v6/internal/subsystems/alerts.md",
		"docs/release-control/v6/internal/subsystems/api-contracts.md",
		"docs/release-control/v6/internal/subsystems/cloud-paid.md",
		"docs/release-control/v6/internal/subsystems/frontend-primitives.md",
		"docs/release-control/v6/internal/subsystems/monitoring.md",
		"docs/release-control/v6/internal/subsystems/organization-settings.md",
		"docs/release-control/v6/internal/subsystems/patrol-intelligence.md",
		"docs/release-control/v6/internal/subsystems/performance-and-scalability.md",
		"docs/release-control/v6/internal/subsystems/unified-resources.md",
	})
}

func TestSubsystemRegistrySchemaExistsAndDeclaresOwnershipContract(t *testing.T) {
	rel := "docs/release-control/v6/internal/subsystems/registry.schema.json"
	content := readRepoFile(t, rel)
	assertContainsAll(t, rel, content, []string{
		"\"$schema\": \"https://json-schema.org/draft/2020-12/schema\"",
		"\"title\": \"Pulse v6 Subsystem Registry Schema\"",
		"\"verification\"",
		"\"path_policy\"",
		"\"shared_ownership\"",
		"\"lane\"",
		"\"owned_prefixes\"",
	})
}

func TestReleaseControlPlaneFilesExist(t *testing.T) {
	valuesRel := "docs/release-control/internal/AGENT_VALUES.md"
	values := readRepoFile(t, valuesRel)
	assertContainsAll(t, valuesRel, values, []string{
		"# Pulse Agent Values",
		"control_plane.py --agent-entrypoint --pretty",
		"work_claim.py",
	})
	docRel := "docs/release-control/internal/CONTROL_PLANE.md"
	doc := readRepoFile(t, docRel)
	assertContainsAll(t, docRel, doc, []string{
		"# Pulse Release Control Plane",
		"AGENT_VALUES.md",
		"control_plane.json",
		"control_plane_audit.py --check",
		"status_lookup.py",
	})
	jsonRel := "docs/release-control/control_plane.json"
	jsonContent := readRepoFile(t, jsonRel)
	assertContainsAll(t, jsonRel, jsonContent, []string{
		"\"system\": \"pulse-release-control\"",
		"\"agent_values_doc\": \"docs/release-control/internal/AGENT_VALUES.md\"",
		"\"active_profile_id\": \"v6\"",
		"\"prerelease_branch\": \"main\"",
		"\"stable_branch\": \"main\"",
		"\"completion_rule\": \"rc_ready\"",
		"\"completion_rule\": \"manual\"",
		"\"proof_scope\": \"none\"",
		"main is the canonical latest-and-greatest branch",
		"Post-GA active development runs on main",
	})

	var controlPlane map[string]any
	if err := json.Unmarshal([]byte(jsonContent), &controlPlane); err != nil {
		t.Fatalf("failed to parse %s: %v", jsonRel, err)
	}
	activeTargetID, ok := controlPlane["active_target_id"].(string)
	if !ok || activeTargetID == "" {
		t.Fatalf("%s missing active_target_id", jsonRel)
	}
	if activeTargetID != "v6-rc-cut" && activeTargetID != "v6-rc-stabilization" && activeTargetID != "v6-ga-promotion" && activeTargetID != "v6-product-lane-expansion" && activeTargetID != "v6-release-reliability" {
		t.Fatalf("%s has unexpected active_target_id %q", jsonRel, activeTargetID)
	}

	workClaimRel := "scripts/release_control/work_claim.py"
	workClaim := readRepoFile(t, workClaimRel)
	assertContainsAll(t, workClaimRel, workClaim, []string{
		"Reserve and release governed work claims",
		"def claim_work(",
		"def release_claims(",
		"def parse_args(",
	})

	rawTargets, ok := controlPlane["targets"].([]any)
	if !ok || len(rawTargets) == 0 {
		t.Fatalf("%s missing targets", jsonRel)
	}

	targetsByID := map[string]map[string]any{}
	activeCount := 0
	for _, rawTarget := range rawTargets {
		target, ok := rawTarget.(map[string]any)
		if !ok {
			t.Fatalf("%s contains non-object target", jsonRel)
		}
		id, ok := target["id"].(string)
		if !ok || id == "" {
			t.Fatalf("%s target missing id", jsonRel)
		}
		targetsByID[id] = target
		status, _ := target["status"].(string)
		if status == "active" {
			activeCount++
		}
	}

	for _, requiredID := range []string{"v6-rc-cut", "v6-rc-stabilization", "v6-ga-promotion", "v6-product-lane-expansion", "v6-release-reliability"} {
		if _, ok := targetsByID[requiredID]; !ok {
			t.Fatalf("%s missing target %q", jsonRel, requiredID)
		}
	}
	if activeCount != 1 {
		t.Fatalf("%s must contain exactly one active target, found %d", jsonRel, activeCount)
	}
	if status, _ := targetsByID[activeTargetID]["status"].(string); status != "active" {
		t.Fatalf("%s active_target_id %q is not marked active", jsonRel, activeTargetID)
	}
	if status, _ := targetsByID["v6-rc-cut"]["status"].(string); status != "active" && status != "completed" {
		t.Fatalf("%s v6-rc-cut must remain either active or completed", jsonRel)
	}
	if rule, _ := targetsByID["v6-rc-stabilization"]["completion_rule"].(string); rule != "manual" {
		t.Fatalf("%s v6-rc-stabilization must keep completion_rule=manual", jsonRel)
	}
	if scope, _ := targetsByID["v6-rc-stabilization"]["proof_scope"].(string); scope != "none" {
		t.Fatalf("%s v6-rc-stabilization must keep proof_scope=none", jsonRel)
	}
	if rule, _ := targetsByID["v6-product-lane-expansion"]["completion_rule"].(string); rule != "manual" {
		t.Fatalf("%s v6-product-lane-expansion must keep completion_rule=manual", jsonRel)
	}

	schemaRel := "docs/release-control/control_plane.schema.json"
	schemaContent := readRepoFile(t, schemaRel)
	assertContainsAll(t, schemaRel, schemaContent, []string{
		"\"title\": \"Pulse Release Control Plane Schema\"",
		"\"agent_values_doc\"",
		"\"active_profile_id\"",
		"\"active_target_id\"",
		"\"targets\"",
		"\"completion_rule\"",
		"\"prerelease_branch\"",
		"\"stable_branch\"",
	})
}

func TestV6ControlDocsReferenceCanonicalDevelopmentProtocol(t *testing.T) {
	readme := readRepoFile(t, "docs/release-control/v6/README.md")
	assertContainsAll(t, "docs/release-control/v6/README.md", readme, []string{
		"CONTROL_PLANE.md",
		"control_plane.json",
		"CANONICAL_DEVELOPMENT_PROTOCOL.md",
		"status.schema.json",
		"registry.schema.json",
	})
	source := readRepoFile(t, "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md")
	assertContainsAll(t, "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md", source, []string{
		"AGENT_VALUES.md",
		"control_plane.json",
		"CANONICAL_DEVELOPMENT_PROTOCOL.md",
		"status.schema.json",
		"registry.schema.json",
		"status_lookup.py",
	})
	matrix := readRepoFile(t, "docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md")
	assertContainsAll(t, "docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md", matrix, []string{
		"status.json.release_gates",
		"historical-credential-containment",
		"hosted-signup-billing-replay",
		"paid-feature-entitlement-gating",
		"rc-to-ga-promotion-readiness",
		"relay-registration-reconnect-drain",
		"mobile-relay-auth-approvals",
		"msp-provider-tenant-management",
		"organization-user-scope-and-rbac",
		"api-token-scope-and-assignment",
		"upgrade-state-and-entitlement-preservation",
	})
}

func TestStatusSchemaExistsAndDeclaresTypedStatusContract(t *testing.T) {
	rel := "docs/release-control/v6/status.schema.json"
	content := readRepoFile(t, rel)
	assertContainsAll(t, rel, content, []string{
		"\"$schema\": \"https://json-schema.org/draft/2020-12/schema\"",
		"\"title\": \"Pulse v6 Status Schema\"",
		"\"readiness\"",
		"\"readiness_assertion\"",
		"\"proof_command\"",
		"\"proof_commands\"",
		"\"coverage_gap\"",
		"\"candidate_lane\"",
		"\"work_claim\"",
		"\"work_claim_ref\"",
		"\"work_claims\"",
		"\"target_id\"",
		"\"agent_id\"",
		"\"heartbeat_at\"",
		"\"expires_at\"",
		"\"proposed_resolution\"",
		"\"blocking_level\"",
		"\"proof_type\"",
		"\"open_decision\"",
		"\"resolved_decision\"",
		"\"owner-action\"",
		"\"release_gate_closure_contract\"",
		"\"historical-credential-containment\"",
		"\"credential_provider_closure_record\"",
		"\"credential_replacement_deployment_record\"",
		"\"provider_closure_records\"",
		"\"replacement_deployment_records\"",
		"\"optional-after-containment\"",
		"\"lane_ids\"",
		"\"direct-repo-sessions\"",
		"\"const\": \"bounded-residual\"",
		"\"const\": \"target-met\"",
		"\"const\": \"partial\"",
		"\"const\": \"not-started\"",
		"\"const\": \"blocked\"",
		"\"lane_blocker_ref\"",
		"\"not\": {",
		"\"minItems\": 1",
		"\"maxItems\": 0",
	})
}

func TestSourceOfTruthStaysStableAndNonOperational(t *testing.T) {
	rel := "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md"
	content := readRepoFile(t, rel)
	assertContainsAll(t, rel, content, []string{
		"## Canonical Control Files",
		"status.json",
		"status.schema.json",
		"registry.schema.json",
		"CANONICAL_DEVELOPMENT_PROTOCOL.md",
	})
	assertContainsNone(t, rel, content, []string{
		"## Priority Engine",
		"### Lane Scoring Rubrics",
		"## Session Contract",
		"## Current Lane Snapshot",
		"| Lane ID | Lane | Target |",
		"Evidence:",
	})
}

func TestStatusJSONStaysInSyncWithSourceOfTruth(t *testing.T) {
	source := readRepoFile(t, "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md")
	sourceUpdated := sourceOfTruthLastUpdated(t, source)
	status := statusJSON(t)

	updatedAt, ok := status["updated_at"].(string)
	if !ok {
		t.Fatalf("status.json missing string updated_at")
	}
	if updatedAt != sourceUpdated {
		t.Fatalf("status.json updated_at = %q, want %q", updatedAt, sourceUpdated)
	}
}

func TestStatusJSONHasStrictTopLevelSchema(t *testing.T) {
	status := statusJSON(t)

	requiredStringFields := map[string]string{
		"version":              "6.0",
		"updated_at":           sourceOfTruthLastUpdated(t, readRepoFile(t, "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md")),
		"execution_model":      "direct-repo-sessions",
		"source_of_truth_file": "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md",
	}
	for field, want := range requiredStringFields {
		got, ok := status[field].(string)
		if !ok {
			t.Fatalf("status.json missing string %s", field)
		}
		if got != want {
			t.Fatalf("status.json %s = %q, want %q", field, got, want)
		}
	}

	if _, ok := status["open_decisions"].([]any); !ok {
		t.Fatalf("status.json missing open_decisions list")
	}
	if _, ok := status["lane_followups"].([]any); !ok {
		t.Fatalf("status.json missing lane_followups list")
	}
	if _, ok := status["coverage_gaps"].([]any); !ok {
		t.Fatalf("status.json missing coverage_gaps list")
	}
	if _, ok := status["candidate_lanes"].([]any); !ok {
		t.Fatalf("status.json missing candidate_lanes list")
	}
	if _, ok := status["work_claims"].([]any); !ok {
		t.Fatalf("status.json missing work_claims list")
	}
	if candidateLanes, ok := status["candidate_lanes"].([]any); ok {
		for index, rawCandidate := range candidateLanes {
			candidate, ok := rawCandidate.(map[string]any)
			if !ok {
				t.Fatalf("status.json candidate_lanes[%d] contains non-object entry", index)
			}
			targetID, ok := candidate["target_id"].(string)
			if !ok || strings.TrimSpace(targetID) == "" {
				t.Fatalf("status.json candidate_lanes[%d] missing target_id", index)
			}
		}
	}
	if _, ok := status["resolved_decisions"].([]any); !ok {
		t.Fatalf("status.json missing resolved_decisions list")
	}
	if assertions, ok := status["readiness_assertions"].([]any); !ok || len(assertions) == 0 {
		t.Fatalf("status.json readiness_assertions must be a non-empty list")
	}
	readiness, ok := status["readiness"].(map[string]any)
	if !ok {
		t.Fatalf("status.json missing readiness object")
	}
	if gates, ok := status["release_gates"].([]any); !ok || len(gates) == 0 {
		t.Fatalf("status.json release_gates must be a non-empty list")
	}
	if got, ok := readiness["repo_ready_rule"].(string); !ok || got != "all lanes complete or bounded-residual and evidence-present plus all repo-ready assertions passed" {
		t.Fatalf("status.json readiness.repo_ready_rule = %#v, want %q", readiness["repo_ready_rule"], "all lanes complete or bounded-residual and evidence-present plus all repo-ready assertions passed")
	}
	if got, ok := readiness["rc_ready_rule"].(string); !ok || got != "repo_ready plus all rc-ready assertions passed plus zero rc-ready open_decisions plus all rc-ready release_gates passed" {
		t.Fatalf("status.json readiness.rc_ready_rule = %#v, want %q", readiness["rc_ready_rule"], "repo_ready plus all rc-ready assertions passed plus zero rc-ready open_decisions plus all rc-ready release_gates passed")
	}
	if got, ok := readiness["release_ready_rule"].(string); !ok || got != "rc_ready plus all release-ready assertions passed plus zero release-ready open_decisions plus all release-ready release_gates passed" {
		t.Fatalf("status.json readiness.release_ready_rule = %#v, want %q", readiness["release_ready_rule"], "rc_ready plus all release-ready assertions passed plus zero release-ready open_decisions plus all release-ready release_gates passed")
	}
	if _, ok := readiness["repo_ready"]; ok {
		t.Fatalf("status.json readiness must not hand-maintain repo_ready")
	}
	if _, ok := readiness["rc_ready"]; ok {
		t.Fatalf("status.json readiness must not hand-maintain rc_ready")
	}
	if _, ok := readiness["release_ready"]; ok {
		t.Fatalf("status.json readiness must not hand-maintain release_ready")
	}
	if _, ok := readiness["rc_blockers"]; ok {
		t.Fatalf("status.json readiness must not hand-maintain rc_blockers")
	}
	if _, ok := readiness["release_blockers"]; ok {
		t.Fatalf("status.json readiness must not hand-maintain release_blockers")
	}
}

func TestStatusJSONSourcePrecedenceIncludesCanonicalGovernanceFiles(t *testing.T) {
	status := statusJSON(t)

	raw, ok := status["source_precedence"].([]any)
	if !ok {
		t.Fatalf("status.json missing source_precedence list")
	}

	var got []string
	for _, entry := range raw {
		value, ok := entry.(string)
		if !ok {
			t.Fatalf("status.json source_precedence contains non-string entry")
		}
		got = append(got, value)
	}

	want := []string{
		"docs/release-control/v6/internal/SOURCE_OF_TRUTH.md",
		"docs/release-control/v6/internal/status.json",
		"docs/release-control/v6/status.schema.json",
		"docs/release-control/v6/internal/CANONICAL_DEVELOPMENT_PROTOCOL.md",
		"docs/release-control/v6/internal/subsystems/registry.json",
		"docs/release-control/v6/internal/subsystems/registry.schema.json",
	}
	if len(got) != len(want) {
		t.Fatalf("status.json source_precedence = %v, want %v", got, want)
	}
	for i, expected := range want {
		if got[i] != expected {
			t.Fatalf("status.json source_precedence[%d] = %q, want %q", i, got[i], expected)
		}
	}
}

func TestStatusJSONLaneEvidenceReferencesAreStructured(t *testing.T) {
	status := statusJSON(t)

	scope, ok := status["scope"].(map[string]any)
	if !ok {
		t.Fatalf("status.json missing scope object")
	}

	rawRepos, ok := scope["active_repos"].([]any)
	if !ok {
		t.Fatalf("status.json scope missing active_repos list")
	}

	activeRepos := make(map[string]struct{}, len(rawRepos))
	for _, raw := range rawRepos {
		repo, ok := raw.(string)
		if !ok {
			t.Fatalf("status.json active_repos contains non-string entry")
		}
		activeRepos[repo] = struct{}{}
	}

	policy, ok := status["evidence_reference_policy"].(map[string]any)
	if !ok {
		t.Fatalf("status.json missing evidence_reference_policy object")
	}
	if got, ok := policy["format"].(string); !ok || got != "repo-qualified-relative-paths" {
		t.Fatalf("status.json evidence_reference_policy.format = %#v, want %q", policy["format"], "repo-qualified-relative-paths")
	}
	if got, ok := policy["local_repo"].(string); !ok || got != "pulse" {
		t.Fatalf("status.json evidence_reference_policy.local_repo = %#v, want %q", policy["local_repo"], "pulse")
	}

	rawKinds, ok := policy["allowed_kinds"].([]any)
	if !ok {
		t.Fatalf("status.json evidence_reference_policy.allowed_kinds missing list")
	}
	var allowedKinds []string
	for _, raw := range rawKinds {
		kind, ok := raw.(string)
		if !ok {
			t.Fatalf("status.json evidence_reference_policy.allowed_kinds contains non-string entry")
		}
		allowedKinds = append(allowedKinds, kind)
	}

	lanes, ok := status["lanes"].([]any)
	if !ok || len(lanes) == 0 {
		t.Fatalf("status.json missing lanes list")
	}

	seenIDs := make(map[string]struct{}, len(lanes))
	for _, rawLane := range lanes {
		lane, ok := rawLane.(map[string]any)
		if !ok {
			t.Fatalf("status.json lanes contains non-object entry")
		}

		laneID, ok := lane["id"].(string)
		if !ok || laneID == "" {
			t.Fatalf("status.json lane missing id")
		}
		if _, exists := seenIDs[laneID]; exists {
			t.Fatalf("status.json lane id %q duplicated", laneID)
		}
		seenIDs[laneID] = struct{}{}

		rawEvidence, ok := lane["evidence"].([]any)
		if !ok || len(rawEvidence) == 0 {
			t.Fatalf("status.json lane %q missing evidence list", laneID)
		}
		if _, ok := lane["name"].(string); !ok {
			t.Fatalf("status.json lane %q missing string name", laneID)
		}
		statusValue, ok := lane["status"].(string)
		if !ok || !slices.Contains([]string{"not-started", "partial", "target-met", "blocked"}, statusValue) {
			t.Fatalf("status.json lane %q has invalid status %#v", laneID, lane["status"])
		}
		completion, ok := lane["completion"].(map[string]any)
		if !ok {
			t.Fatalf("status.json lane %q missing completion object", laneID)
		}
		completionState, ok := completion["state"].(string)
		if !ok || !slices.Contains([]string{"open", "bounded-residual", "complete"}, completionState) {
			t.Fatalf("status.json lane %q has invalid completion.state %#v", laneID, completion["state"])
		}
		if completionSummary, ok := completion["summary"].(string); !ok || strings.TrimSpace(completionSummary) == "" {
			t.Fatalf("status.json lane %q missing non-empty completion.summary", laneID)
		}
		rawTracking, ok := completion["tracking"].([]any)
		if !ok {
			t.Fatalf("status.json lane %q missing completion.tracking list", laneID)
		}
		rawBlockers, ok := lane["blockers"].([]any)
		if !ok {
			t.Fatalf("status.json lane %q missing blockers list", laneID)
		}
		if completionState == "open" && len(rawTracking) != 0 {
			t.Fatalf("status.json lane %q must not declare completion.tracking while completion.state is open", laneID)
		}
		if completionState == "open" && statusValue == "target-met" {
			t.Fatalf("status.json lane %q must not pair completion.state open with status target-met", laneID)
		}
		if statusValue == "not-started" && completionState != "open" {
			t.Fatalf("status.json lane %q must pair status not-started with completion.state open", laneID)
		}
		if statusValue == "blocked" && completionState != "open" {
			t.Fatalf("status.json lane %q must pair status blocked with completion.state open", laneID)
		}
		if statusValue == "blocked" && len(rawBlockers) == 0 {
			t.Fatalf("status.json lane %q must declare blockers while status is blocked", laneID)
		}
		if statusValue != "blocked" && len(rawBlockers) != 0 {
			t.Fatalf("status.json lane %q must not declare blockers while status is %s", laneID, statusValue)
		}
		if completionState == "bounded-residual" && statusValue != "partial" {
			t.Fatalf("status.json lane %q must pair completion.state bounded-residual with status partial", laneID)
		}
		if completionState == "complete" && len(rawTracking) != 0 {
			t.Fatalf("status.json lane %q must not declare completion.tracking while completion.state is complete", laneID)
		}
		if completionState == "complete" && statusValue != "target-met" {
			t.Fatalf("status.json lane %q must pair completion.state complete with status target-met", laneID)
		}
		for _, rawTrackingRef := range rawTracking {
			trackingRef, ok := rawTrackingRef.(map[string]any)
			if !ok {
				t.Fatalf("status.json lane %q completion.tracking contains non-object entry", laneID)
			}
			kind, ok := trackingRef["kind"].(string)
			if !ok || !slices.Contains([]string{"lane-followup", "readiness-assertion", "release-gate", "open-decision"}, kind) {
				t.Fatalf("status.json lane %q has invalid completion.tracking kind %#v", laneID, trackingRef["kind"])
			}
			id, ok := trackingRef["id"].(string)
			if !ok || strings.TrimSpace(id) == "" {
				t.Fatalf("status.json lane %q completion.tracking missing non-empty id", laneID)
			}
		}
		for _, rawBlockerRef := range rawBlockers {
			blockerRef, ok := rawBlockerRef.(map[string]any)
			if !ok {
				t.Fatalf("status.json lane %q blockers contains non-object entry", laneID)
			}
			kind, ok := blockerRef["kind"].(string)
			if !ok || !slices.Contains([]string{"readiness-assertion", "release-gate", "open-decision"}, kind) {
				t.Fatalf("status.json lane %q has invalid blocker kind %#v", laneID, blockerRef["kind"])
			}
			id, ok := blockerRef["id"].(string)
			if !ok || strings.TrimSpace(id) == "" {
				t.Fatalf("status.json lane %q blocker missing non-empty id", laneID)
			}
		}

		validateEvidenceRefs(t, activeRepos, allowedKinds, rawEvidence, "status.json lane "+laneID)
	}
}

func TestStatusJSONCoverageGapPlanningStaysTyped(t *testing.T) {
	status := statusJSON(t)

	rawCoverageGaps, ok := status["coverage_gaps"].([]any)
	if !ok {
		t.Fatalf("status.json missing coverage_gaps list")
	}
	rawCandidateLanes, ok := status["candidate_lanes"].([]any)
	if !ok {
		t.Fatalf("status.json missing candidate_lanes list")
	}

	candidateGapRefCounts := make(map[string]int)
	for index, rawCandidate := range rawCandidateLanes {
		candidate, ok := rawCandidate.(map[string]any)
		if !ok {
			t.Fatalf("status.json candidate_lanes[%d] contains non-object entry", index)
		}
		rawGapIDs, ok := candidate["coverage_gap_ids"].([]any)
		if !ok || len(rawGapIDs) == 0 {
			t.Fatalf("status.json candidate_lanes[%d] missing coverage_gap_ids", index)
		}
		for _, rawGapID := range rawGapIDs {
			gapID, ok := rawGapID.(string)
			if !ok || strings.TrimSpace(gapID) == "" {
				t.Fatalf("status.json candidate_lanes[%d] has invalid coverage_gap_ids entry %#v", index, rawGapID)
			}
			candidateGapRefCounts[gapID]++
		}
	}

	laneShapingResolutions := map[string]struct{}{
		"new-lane":       {},
		"lane-split":     {},
		"lane-expansion": {},
	}
	for index, rawGap := range rawCoverageGaps {
		gap, ok := rawGap.(map[string]any)
		if !ok {
			t.Fatalf("status.json coverage_gaps[%d] contains non-object entry", index)
		}
		gapID, ok := gap["id"].(string)
		if !ok || strings.TrimSpace(gapID) == "" {
			t.Fatalf("status.json coverage_gaps[%d] missing id", index)
		}
		statusValue, ok := gap["status"].(string)
		if !ok || !slices.Contains([]string{"discovered", "triaged", "planned"}, statusValue) {
			t.Fatalf("status.json coverage_gap %q has invalid status %#v", gapID, gap["status"])
		}
		proposedResolution, ok := gap["proposed_resolution"].(string)
		if !ok || strings.TrimSpace(proposedResolution) == "" {
			t.Fatalf("status.json coverage_gap %q missing proposed_resolution", gapID)
		}

		_, laneShaping := laneShapingResolutions[proposedResolution]
		referencedByCandidateLane := candidateGapRefCounts[gapID] > 0
		if laneShaping && referencedByCandidateLane && statusValue != "planned" {
			t.Fatalf(
				"status.json coverage_gap %q is referenced by candidate_lanes but status is %q; lane-shaping planned gaps must be marked planned",
				gapID,
				statusValue,
			)
		}
		if laneShaping && statusValue == "planned" && !referencedByCandidateLane {
			t.Fatalf(
				"status.json coverage_gap %q is planned for %q but has no candidate_lane reference",
				gapID,
				proposedResolution,
			)
		}
		if proposedResolution == "target-update" && referencedByCandidateLane {
			t.Fatalf(
				"status.json coverage_gap %q uses target-update but is referenced by candidate_lanes",
				gapID,
			)
		}
	}
}

func TestStatusJSONScopeDeclaresControlPlaneAndRepoCatalog(t *testing.T) {
	status := statusJSON(t)

	scope, ok := status["scope"].(map[string]any)
	if !ok {
		t.Fatalf("status.json missing scope object")
	}

	rawActiveRepos, ok := scope["active_repos"].([]any)
	if !ok || len(rawActiveRepos) == 0 {
		t.Fatalf("status.json scope missing active_repos list")
	}
	var activeRepos []string
	for _, raw := range rawActiveRepos {
		repo, ok := raw.(string)
		if !ok || strings.TrimSpace(repo) == "" {
			t.Fatalf("status.json active_repos contains invalid entry")
		}
		activeRepos = append(activeRepos, repo)
	}

	controlPlaneRepo, ok := scope["control_plane_repo"].(string)
	if !ok || controlPlaneRepo != "pulse" {
		t.Fatalf("status.json scope.control_plane_repo = %#v, want %q", scope["control_plane_repo"], "pulse")
	}

	rawCatalog, ok := scope["repo_catalog"].([]any)
	if !ok || len(rawCatalog) != len(activeRepos) {
		t.Fatalf("status.json scope.repo_catalog must mirror active_repos")
	}

	var catalogIDs []string
	for _, raw := range rawCatalog {
		entry, ok := raw.(map[string]any)
		if !ok {
			t.Fatalf("status.json scope.repo_catalog contains non-object entry")
		}
		repoID, ok := entry["id"].(string)
		if !ok || strings.TrimSpace(repoID) == "" {
			t.Fatalf("status.json scope.repo_catalog entry missing id")
		}
		visibility, ok := entry["visibility"].(string)
		if !ok || !slices.Contains([]string{"public", "private"}, visibility) {
			t.Fatalf("status.json scope.repo_catalog %q has invalid visibility %#v", repoID, entry["visibility"])
		}
		purpose, ok := entry["purpose"].(string)
		if !ok || strings.TrimSpace(purpose) == "" {
			t.Fatalf("status.json scope.repo_catalog %q missing purpose", repoID)
		}
		catalogIDs = append(catalogIDs, repoID)
	}

	if !slices.Equal(activeRepos, catalogIDs) {
		t.Fatalf("status.json scope.repo_catalog ids = %v, want %v", catalogIDs, activeRepos)
	}
	if !slices.Contains(catalogIDs, controlPlaneRepo) {
		t.Fatalf("status.json scope.repo_catalog missing control-plane repo %q", controlPlaneRepo)
	}
}

func TestStatusJSONReadinessAssertionsAreTypedRecords(t *testing.T) {
	status := statusJSON(t)
	laneIDs := statusLaneIDs(t, status)

	scope, ok := status["scope"].(map[string]any)
	if !ok {
		t.Fatalf("status.json missing scope object")
	}
	rawRepos, ok := scope["active_repos"].([]any)
	if !ok {
		t.Fatalf("status.json scope missing active_repos list")
	}
	activeRepos := make(map[string]struct{}, len(rawRepos))
	for _, raw := range rawRepos {
		repo, ok := raw.(string)
		if !ok {
			t.Fatalf("status.json active_repos contains non-string entry")
		}
		activeRepos[repo] = struct{}{}
	}

	policy, ok := status["evidence_reference_policy"].(map[string]any)
	if !ok {
		t.Fatalf("status.json missing evidence_reference_policy object")
	}
	rawKinds, ok := policy["allowed_kinds"].([]any)
	if !ok {
		t.Fatalf("status.json evidence_reference_policy.allowed_kinds missing list")
	}
	var allowedKinds []string
	for _, raw := range rawKinds {
		kind, ok := raw.(string)
		if !ok {
			t.Fatalf("status.json evidence_reference_policy.allowed_kinds contains non-string entry")
		}
		allowedKinds = append(allowedKinds, kind)
	}

	rawGates, ok := status["release_gates"].([]any)
	if !ok {
		t.Fatalf("status.json missing release_gates list")
	}
	releaseGateIDs := make(map[string]struct{}, len(rawGates))
	releaseGateBlockingLevels := make(map[string]string, len(rawGates))
	for _, raw := range rawGates {
		gate, ok := raw.(map[string]any)
		if !ok {
			t.Fatalf("status.json release_gates contains non-object entry")
		}
		id, ok := gate["id"].(string)
		if !ok || id == "" {
			t.Fatalf("status.json release_gate missing id")
		}
		releaseGateIDs[id] = struct{}{}
		blockingLevel, ok := gate["blocking_level"].(string)
		if !ok || !slices.Contains([]string{"rc-ready", "release-ready"}, blockingLevel) {
			t.Fatalf("status.json release_gate %q has invalid blocking_level %#v", id, gate["blocking_level"])
		}
		releaseGateBlockingLevels[id] = blockingLevel
	}

	rawAssertions, ok := status["readiness_assertions"].([]any)
	if !ok || len(rawAssertions) == 0 {
		t.Fatalf("status.json readiness_assertions must be a non-empty list")
	}

	validKinds := []string{"invariant", "journey", "trust-gate"}
	validBlockingLevels := []string{"repo-ready", "rc-ready", "release-ready"}
	validProofTypes := []string{"automated", "manual", "hybrid"}
	seenIDs := make(map[string]struct{}, len(rawAssertions))

	for _, rawAssertion := range rawAssertions {
		assertion, ok := rawAssertion.(map[string]any)
		if !ok {
			t.Fatalf("status.json readiness_assertions contains non-object entry")
		}

		id, ok := assertion["id"].(string)
		if !ok || id == "" {
			t.Fatalf("status.json readiness_assertion missing id")
		}
		if _, exists := seenIDs[id]; exists {
			t.Fatalf("status.json readiness_assertion id %q duplicated", id)
		}
		seenIDs[id] = struct{}{}

		if summary, ok := assertion["summary"].(string); !ok || strings.TrimSpace(summary) == "" {
			t.Fatalf("status.json readiness_assertion %q missing summary", id)
		}
		if kind, ok := assertion["kind"].(string); !ok || !slices.Contains(validKinds, kind) {
			t.Fatalf("status.json readiness_assertion %q has invalid kind %#v", id, assertion["kind"])
		}
		blockingLevel, ok := assertion["blocking_level"].(string)
		if !ok || !slices.Contains(validBlockingLevels, blockingLevel) {
			t.Fatalf("status.json readiness_assertion %q has invalid blocking_level %#v", id, assertion["blocking_level"])
		}
		proofType, ok := assertion["proof_type"].(string)
		if !ok || !slices.Contains(validProofTypes, proofType) {
			t.Fatalf("status.json readiness_assertion %q has invalid proof_type %#v", id, assertion["proof_type"])
		}

		rawLaneIDs, ok := assertion["lane_ids"].([]any)
		if !ok || len(rawLaneIDs) == 0 {
			t.Fatalf("status.json readiness_assertion %q missing lane_ids", id)
		}
		for _, rawLaneID := range rawLaneIDs {
			laneID, ok := rawLaneID.(string)
			if !ok || laneID == "" {
				t.Fatalf("status.json readiness_assertion %q lane_ids contains invalid entry", id)
			}
			if _, ok := laneIDs[laneID]; !ok {
				t.Fatalf("status.json readiness_assertion %q references unknown lane_id %q", id, laneID)
			}
		}

		rawSubsystemIDs, ok := assertion["subsystem_ids"].([]any)
		if !ok {
			t.Fatalf("status.json readiness_assertion %q missing subsystem_ids", id)
		}
		for _, rawSubsystemID := range rawSubsystemIDs {
			subsystemID, ok := rawSubsystemID.(string)
			if !ok || subsystemID == "" {
				t.Fatalf("status.json readiness_assertion %q subsystem_ids contains invalid entry", id)
			}
		}

		rawReleaseGateIDs, ok := assertion["release_gate_ids"].([]any)
		if !ok {
			t.Fatalf("status.json readiness_assertion %q missing release_gate_ids", id)
		}
		for _, rawReleaseGateID := range rawReleaseGateIDs {
			releaseGateID, ok := rawReleaseGateID.(string)
			if !ok || releaseGateID == "" {
				t.Fatalf("status.json readiness_assertion %q release_gate_ids contains invalid entry", id)
			}
			if _, ok := releaseGateIDs[releaseGateID]; !ok {
				t.Fatalf("status.json readiness_assertion %q references unknown release_gate_id %q", id, releaseGateID)
			}
			if releaseGateBlockingLevels[releaseGateID] != blockingLevel {
				t.Fatalf("status.json readiness_assertion %q links release_gate_id %q with blocking_level %q, want %q", id, releaseGateID, releaseGateBlockingLevels[releaseGateID], blockingLevel)
			}
		}
		if proofType == "automated" && len(rawReleaseGateIDs) != 0 {
			t.Fatalf("status.json readiness_assertion %q proof_type automated must not carry release_gate_ids", id)
		}
		if proofType != "automated" && len(rawReleaseGateIDs) == 0 {
			t.Fatalf("status.json readiness_assertion %q proof_type %q must carry release_gate_ids", id, proofType)
		}
		if rawProofCommands, ok := assertion["proof_commands"]; ok {
			if count := validateProofCommands(t, rawProofCommands, "status.json readiness_assertion "+id); count == 0 {
				t.Fatalf("status.json readiness_assertion %q proof_commands must not be empty", id)
			}
		} else if proofType == "automated" {
			t.Fatalf("status.json readiness_assertion %q proof_type automated must carry proof_commands", id)
		}

		rawEvidence, ok := assertion["evidence"].([]any)
		if !ok || len(rawEvidence) == 0 {
			t.Fatalf("status.json readiness_assertion %q missing evidence list", id)
		}
		validateEvidenceRefs(t, activeRepos, allowedKinds, rawEvidence, "status.json readiness_assertion "+id)
	}
}

func TestStatusJSONOpenDecisionsAreTypedRecords(t *testing.T) {
	status := statusJSON(t)
	laneIDs := statusLaneIDs(t, status)

	rawDecisions, ok := status["open_decisions"].([]any)
	if !ok {
		t.Fatalf("status.json missing open_decisions list")
	}

	seenIDs := make(map[string]struct{}, len(rawDecisions))
	dateRe := regexp.MustCompile(`^[0-9]{4}-[0-9]{2}-[0-9]{2}$`)
	for _, rawDecision := range rawDecisions {
		decision, ok := rawDecision.(map[string]any)
		if !ok {
			t.Fatalf("status.json open_decisions contains non-object entry")
		}

		id, ok := decision["id"].(string)
		if !ok || id == "" {
			t.Fatalf("status.json open_decision missing id")
		}
		if _, exists := seenIDs[id]; exists {
			t.Fatalf("status.json open_decision id %q duplicated", id)
		}
		seenIDs[id] = struct{}{}

		if summary, ok := decision["summary"].(string); !ok || strings.TrimSpace(summary) == "" {
			t.Fatalf("status.json open_decision %q missing summary", id)
		}
		if owner, ok := decision["owner"].(string); !ok || strings.TrimSpace(owner) == "" {
			t.Fatalf("status.json open_decision %q missing owner", id)
		}
		if blockingLevel, ok := decision["blocking_level"].(string); !ok || !slices.Contains([]string{"rc-ready", "release-ready"}, blockingLevel) {
			t.Fatalf("status.json open_decision %q has invalid blocking_level %#v", id, decision["blocking_level"])
		}
		if statusValue, ok := decision["status"].(string); !ok || !slices.Contains([]string{"open", "blocked", "owner-action"}, statusValue) {
			t.Fatalf("status.json open_decision %q has invalid status %#v", id, decision["status"])
		}
		openedAt, ok := decision["opened_at"].(string)
		if !ok || !dateRe.MatchString(openedAt) {
			t.Fatalf("status.json open_decision %q missing valid opened_at date", id)
		}
		rawLaneIDs, ok := decision["lane_ids"].([]any)
		if !ok || len(rawLaneIDs) == 0 {
			t.Fatalf("status.json open_decision %q missing lane_ids", id)
		}
		if rawSubsystemIDs, ok := decision["subsystem_ids"].([]any); !ok {
			t.Fatalf("status.json open_decision %q missing subsystem_ids", id)
		} else {
			for _, rawSubsystemID := range rawSubsystemIDs {
				subsystemID, ok := rawSubsystemID.(string)
				if !ok || subsystemID == "" {
					t.Fatalf("status.json open_decision %q subsystem_ids contains invalid entry", id)
				}
			}
		}
		for _, rawLaneID := range rawLaneIDs {
			laneID, ok := rawLaneID.(string)
			if !ok || laneID == "" {
				t.Fatalf("status.json open_decision %q lane_ids contains invalid entry", id)
			}
			if _, ok := laneIDs[laneID]; !ok {
				t.Fatalf("status.json open_decision %q references unknown lane_id %q", id, laneID)
			}
		}
	}
}

func TestStatusJSONLaneFollowupsAreTypedRecords(t *testing.T) {
	status := statusJSON(t)
	laneIDs := statusLaneIDs(t, status)
	laneTrackingByLane := make(map[string][]map[string]any)
	rawLanes, ok := status["lanes"].([]any)
	if !ok {
		t.Fatalf("status.json missing lanes list")
	}
	for _, rawLane := range rawLanes {
		lane, ok := rawLane.(map[string]any)
		if !ok {
			t.Fatalf("status.json lanes contains non-object entry")
		}
		laneID, _ := lane["id"].(string)
		completion, ok := lane["completion"].(map[string]any)
		if !ok {
			t.Fatalf("status.json lane %q missing completion object", laneID)
		}
		completionState, _ := completion["state"].(string)
		if completionState != "bounded-residual" {
			continue
		}
		rawTracking, ok := completion["tracking"].([]any)
		if !ok {
			t.Fatalf("status.json lane %q missing completion.tracking list", laneID)
		}
		for _, rawTrackingRef := range rawTracking {
			trackingRef, ok := rawTrackingRef.(map[string]any)
			if !ok {
				t.Fatalf("status.json lane %q completion.tracking contains non-object entry", laneID)
			}
			laneTrackingByLane[laneID] = append(laneTrackingByLane[laneID], trackingRef)
		}
	}

	rawFollowups, ok := status["lane_followups"].([]any)
	if !ok {
		t.Fatalf("status.json missing lane_followups list")
	}

	seenIDs := make(map[string]struct{}, len(rawFollowups))
	dateRe := regexp.MustCompile(`^[0-9]{4}-[0-9]{2}-[0-9]{2}$`)
	for _, rawFollowup := range rawFollowups {
		followup, ok := rawFollowup.(map[string]any)
		if !ok {
			t.Fatalf("status.json lane_followups contains non-object entry")
		}

		id, ok := followup["id"].(string)
		if !ok || id == "" {
			t.Fatalf("status.json lane_followup missing id")
		}
		if _, exists := seenIDs[id]; exists {
			t.Fatalf("status.json lane_followup id %q duplicated", id)
		}
		seenIDs[id] = struct{}{}

		if summary, ok := followup["summary"].(string); !ok || strings.TrimSpace(summary) == "" {
			t.Fatalf("status.json lane_followup %q missing summary", id)
		}
		if owner, ok := followup["owner"].(string); !ok || strings.TrimSpace(owner) == "" {
			t.Fatalf("status.json lane_followup %q missing owner", id)
		}
		if statusValue, ok := followup["status"].(string); !ok || !slices.Contains([]string{"planned", "active", "parked"}, statusValue) {
			t.Fatalf("status.json lane_followup %q has invalid status %#v", id, followup["status"])
		}
		recordedAt, ok := followup["recorded_at"].(string)
		if !ok || !dateRe.MatchString(recordedAt) {
			t.Fatalf("status.json lane_followup %q missing valid recorded_at date", id)
		}
		rawLaneIDs, ok := followup["lane_ids"].([]any)
		if !ok || len(rawLaneIDs) != 1 {
			t.Fatalf("status.json lane_followup %q must carry exactly one lane_id", id)
		}
		if rawSubsystemIDs, ok := followup["subsystem_ids"].([]any); !ok {
			t.Fatalf("status.json lane_followup %q missing subsystem_ids", id)
		} else {
			for _, rawSubsystemID := range rawSubsystemIDs {
				subsystemID, ok := rawSubsystemID.(string)
				if !ok || subsystemID == "" {
					t.Fatalf("status.json lane_followup %q subsystem_ids contains invalid entry", id)
				}
			}
		}
		for _, rawLaneID := range rawLaneIDs {
			laneID, ok := rawLaneID.(string)
			if !ok || laneID == "" {
				t.Fatalf("status.json lane_followup %q lane_ids contains invalid entry", id)
			}
			if _, ok := laneIDs[laneID]; !ok {
				t.Fatalf("status.json lane_followup %q references unknown lane_id %q", id, laneID)
			}
			refs := laneTrackingByLane[laneID]
			found := false
			for _, trackingRef := range refs {
				kind, _ := trackingRef["kind"].(string)
				trackingID, _ := trackingRef["id"].(string)
				if kind == "lane-followup" && trackingID == id {
					found = true
					break
				}
			}
			if !found {
				t.Fatalf("status.json lane_followup %q is not referenced by lane %q bounded-residual completion.tracking", id, laneID)
			}
		}
	}
}

func TestStatusJSONResolvedDecisionsAreTypedRecords(t *testing.T) {
	status := statusJSON(t)
	laneIDs := statusLaneIDs(t, status)

	rawDecisions, ok := status["resolved_decisions"].([]any)
	if !ok || len(rawDecisions) == 0 {
		t.Fatalf("status.json missing resolved_decisions list")
	}

	seenIDs := make(map[string]struct{}, len(rawDecisions))
	dateRe := regexp.MustCompile(`^[0-9]{4}-[0-9]{2}-[0-9]{2}$`)
	validKinds := []string{"architecture", "contract", "governance", "migration", "pricing", "release-policy"}
	for _, rawDecision := range rawDecisions {
		decision, ok := rawDecision.(map[string]any)
		if !ok {
			t.Fatalf("status.json resolved_decisions contains non-object entry")
		}

		id, ok := decision["id"].(string)
		if !ok || id == "" {
			t.Fatalf("status.json resolved_decision missing id")
		}
		if _, exists := seenIDs[id]; exists {
			t.Fatalf("status.json resolved_decision id %q duplicated", id)
		}
		seenIDs[id] = struct{}{}

		if summary, ok := decision["summary"].(string); !ok || strings.TrimSpace(summary) == "" {
			t.Fatalf("status.json resolved_decision %q missing summary", id)
		}
		if kind, ok := decision["kind"].(string); !ok || !slices.Contains(validKinds, kind) {
			t.Fatalf("status.json resolved_decision %q has invalid kind %#v", id, decision["kind"])
		}
		decidedAt, ok := decision["decided_at"].(string)
		if !ok || !dateRe.MatchString(decidedAt) {
			t.Fatalf("status.json resolved_decision %q missing valid decided_at date", id)
		}
		rawLaneIDs, ok := decision["lane_ids"].([]any)
		if !ok || len(rawLaneIDs) == 0 {
			t.Fatalf("status.json resolved_decision %q missing lane_ids", id)
		}
		if rawSubsystemIDs, ok := decision["subsystem_ids"].([]any); !ok {
			t.Fatalf("status.json resolved_decision %q missing subsystem_ids", id)
		} else {
			for _, rawSubsystemID := range rawSubsystemIDs {
				subsystemID, ok := rawSubsystemID.(string)
				if !ok || subsystemID == "" {
					t.Fatalf("status.json resolved_decision %q subsystem_ids contains invalid entry", id)
				}
			}
		}
		for _, rawLaneID := range rawLaneIDs {
			laneID, ok := rawLaneID.(string)
			if !ok || laneID == "" {
				t.Fatalf("status.json resolved_decision %q lane_ids contains invalid entry", id)
			}
			if _, ok := laneIDs[laneID]; !ok {
				t.Fatalf("status.json resolved_decision %q references unknown lane_id %q", id, laneID)
			}
		}
	}
}

func TestCanonicalCompletionGuardIsWiredIntoPreCommit(t *testing.T) {
	hook := readRepoFile(t, ".husky/pre-commit")
	assertContainsAll(t, ".husky/pre-commit", hook, []string{
		"governance_stage_guard.py",
		"Running governance stage guard...",
		"staged_commit_shape_guard.py",
		"Running staged commit shape guard...",
		"Running control plane audit...",
		"control_plane_audit.py --check --staged",
		"canonical_completion_guard.py",
		"Running canonical completion guard...",
		"browser_verification_guard.py",
		"Running browser verification guard...",
		"Running status audit...",
		"status_audit.py --check",
		"Running registry audit...",
		"registry_audit.py --check",
		"Running contract audit...",
		"contract_audit.py --check",
		"Running governance guardrail tests...",
		"go test ./internal/repoctl -count=1",
		"Running readiness assertion guard...",
		"readiness_assertion_guard.py --staged --active-target --proof-type automated",
		"canonical_completion_guard_test.py",
		"browser_verification_guard_test.py",
		"control_plane_audit_test.py",
		"contract_audit_test.py",
		"format_staged_go_test.py",
		"governance_stage_guard_test.py",
		"release_promotion_policy_support_test.py",
		"registry_audit_test.py",
		"readiness_assertion_guard_test.py",
		"staged_commit_shape_guard_test.py",
		"status_audit_test.py",
		"subsystem_lookup_test.py",
		"format_staged_go.py",
	})
	assertContainsNone(t, ".husky/pre-commit", hook, []string{
		"gofmt -w -s .",
		"git diff --cached --diff-filter=d --name-only -z | xargs -0 -r git add",
	})

	script := readRepoFile(t, "scripts/release_control/canonical_completion_guard.py")
	assertContainsAll(t, "scripts/release_control/canonical_completion_guard.py", script, []string{
		"DEFAULT_CONTROL_PLANE",
		"SUBSYSTEM_REGISTRY",
		"load_subsystem_rules",
		"build_verification_requirements",
		"check_staged_contracts",
		"verification",
		"path_policies",
		"test_prefixes",
	})

	statusAudit := readRepoFile(t, "scripts/release_control/status_audit.py")
	assertContainsAll(t, "scripts/release_control/status_audit.py", statusAudit, []string{
		"ACTIVE_PROFILE_ID",
		"ACTIVE_TARGET",
		"STATUS_PATH",
		"STATUS_SCHEMA_PATH",
		"repo_root_for_name",
		"audit_status_payload",
		"readiness_assertions",
		"release_gates",
		"lane_followups",
		"open_decisions",
		"resolved_decisions",
		"subsystem_ids",
		"completion_state",
		"derived_status",
		"--check",
	})

	controlPlaneAudit := readRepoFile(t, "scripts/release_control/control_plane_audit.py")
	assertContainsAll(t, "scripts/release_control/control_plane_audit.py", controlPlaneAudit, []string{
		"validate_control_plane_payload",
		"current_status_report",
		"completion_met",
		"active target",
		"--check",
	})

	assertionGuard := readRepoFile(t, "scripts/release_control/readiness_assertion_guard.py")
	assertContainsAll(t, "scripts/release_control/readiness_assertion_guard.py", assertionGuard, []string{
		"DEFAULT_CONTROL_PLANE",
		"STATUS_REL",
		"active_target_blocking_levels",
		"selected_proof_commands",
		"run_selected_proof_commands",
		"--active-target",
		"--blocking-level",
		"--proof-type",
		"proof_commands",
	})

	registryAudit := readRepoFile(t, "scripts/release_control/registry_audit.py")
	assertContainsAll(t, "scripts/release_control/registry_audit.py", registryAudit, []string{
		"DEFAULT_CONTROL_PLANE",
		"REGISTRY_PATH",
		"REGISTRY_SCHEMA_PATH",
		"audit_registry_payload",
		"require_explicit_path_policy_coverage",
		"tracked_repo_files",
		"--check",
	})

	contractAudit := readRepoFile(t, "scripts/release_control/contract_audit.py")
	assertContainsAll(t, "scripts/release_control/contract_audit.py", contractAudit, []string{
		"DEFAULT_CONTROL_PLANE",
		"CONTRACTS_DIR",
		"TEMPLATE_REL",
		"Contract Metadata",
		"audit_contract_payload",
		"contract metadata",
		"--repo-scope",
		"--check",
	})

	lookup := readRepoFile(t, "scripts/release_control/subsystem_lookup.py")
	assertContainsAll(t, "scripts/release_control/subsystem_lookup.py", lookup, []string{
		"lookup_paths",
		"verification_requirement",
		"lane_context",
		"status_summary",
		"open_decisions",
		"subsystem_ids",
		"--files-from-stdin",
		"subsystem_matches_path",
	})

	stageGuard := readRepoFile(t, "scripts/release_control/governance_stage_guard.py")
	assertContainsAll(t, "scripts/release_control/governance_stage_guard.py", stageGuard, []string{
		"CONTROL_PLANE_REL",
		"WORKTREE_SENSITIVE_PREFIXES",
		"WORKTREE_SENSITIVE_EXACT_FILES",
		"STAGED_EXECUTION_EXACT_FILES",
		"internal/repoctl/",
		"scripts/release_control/",
		".husky/pre-commit",
		"release_promotion_policy_test.py",
		"unstaged_governance_paths",
		"BLOCKED: unstaged governance file changes detected.",
	})
}

func TestCanonicalGovernanceRunsInCI(t *testing.T) {
	workflow := readRepoFile(t, ".github/workflows/canonical-governance.yml")
	assertContainsAll(t, ".github/workflows/canonical-governance.yml", workflow, []string{
		"name: Canonical Governance",
		"pull_request:",
		"Set up Node.js for frontend governance",
		"cache-dependency-path: repos/pulse/frontend-modern/package-lock.json",
		"Install locked frontend governance dependencies",
		"npm ci --ignore-scripts --no-audit --no-fund",
		"python3 scripts/release_control/canonical_completion_guard.py --files-from-stdin",
		"python3 scripts/release_control/browser_verification_guard.py",
		"python3 scripts/release_control/registry_audit.py --check --repo-scope pulse",
		"python3 scripts/release_control/contract_audit.py --check --repo-scope pulse",
		"python3 scripts/release_control/readiness_assertion_guard.py --active-target --proof-type automated",
		"python3 scripts/release_control/readiness_assertion_guard.py --active-target --proof-type hybrid",
		"go test ./internal/repoctl -count=1",
		"python3 scripts/release_control/canonical_completion_guard_test.py",
		"python3 scripts/release_control/browser_verification_guard_test.py",
		"python3 scripts/release_control/control_plane_audit_test.py",
		"python3 scripts/release_control/contract_audit_test.py",
		"python3 scripts/release_control/governance_stage_guard_test.py",
		"python3 scripts/release_control/registry_audit_test.py",
		"python3 scripts/release_control/readiness_assertion_guard_test.py",
		"python3 scripts/release_control/status_audit_test.py",
		"python3 scripts/release_control/subsystem_lookup_test.py",
	})
	for _, confidentialReference := range []string{
		"secrets.WORKFLOW_PAT",
		"repository: rcourtman/pulse-pro",
		"repository: rcourtman/pulse-enterprise",
		"repository: rcourtman/pulse-mobile",
	} {
		if strings.Contains(workflow, confidentialReference) {
			t.Fatalf("pull-request governance contains confidential reference %q", confidentialReference)
		}
	}

	privateWorkflow := readRepoFile(t, ".github/workflows/canonical-private-governance.yml")
	assertContainsAll(t, ".github/workflows/canonical-private-governance.yml", privateWorkflow, []string{
		"name: Canonical Private Governance",
		"push:",
		"repository: rcourtman/pulse-pro",
		"repository: rcourtman/pulse-enterprise",
		"repository: rcourtman/pulse-mobile",
		"secrets.WORKFLOW_PAT",
		"PULSE_REPO_ROOT_PULSE_PRO",
		"PULSE_REPO_ROOT_PULSE_ENTERPRISE",
		"PULSE_REPO_ROOT_PULSE_MOBILE",
		"python3 scripts/release_control/status_audit.py --check",
		"python3 scripts/release_control/control_plane_audit.py --check",
		"python3 scripts/release_control/registry_audit.py --check",
		"python3 scripts/release_control/contract_audit.py --check",
		"go test ./internal/repoctl -count=1",
	})
	if strings.Contains(privateWorkflow, "pull_request:") || strings.Contains(privateWorkflow, "workflow_dispatch:") {
		t.Fatal("private governance must only load its credential-bearing definition from main pushes")
	}

	install := strings.Index(workflow, "Install locked frontend governance dependencies")
	guard := strings.Index(workflow, "Run canonical completion guard against changed commits")
	if install < 0 || guard < 0 || install > guard {
		t.Fatal("locked frontend governance dependencies must be installed before the per-commit browser guard")
	}
}

func TestLegacyReleaseControlOrchestratorIsRemoved(t *testing.T) {
	for _, rel := range []string{
		"docs/release-control/v6/AUTOMATION_LOOP.md",
		"docs/release-control/v6/loop.config.json",
		"scripts/release_control/e2e_test.sh",
		"scripts/release_control/loopctl.sh",
		"scripts/release_control/orchestrator.py",
		"scripts/release_control/orchestrator_unit_test.py",
	} {
		assertRepoFileMissing(t, rel)
	}

	readme := readRepoFile(t, "docs/release-control/v6/README.md")
	assertContainsNone(t, "docs/release-control/v6/README.md", readme, []string{
		"loop.config.json",
		"AUTOMATION_LOOP.md",
	})

	source := readRepoFile(t, "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md")
	assertContainsNone(t, "docs/release-control/v6/internal/SOURCE_OF_TRUTH.md", source, []string{
		"## Product Review Sweep",
		"## Parallel Execution",
		"loop.config.json",
		"loopctl.sh",
	})

	status := statusJSON(t)
	if _, ok := status["automation_state"]; ok {
		t.Fatalf("status.json should not carry legacy automation_state")
	}
	if got, ok := status["execution_model"].(string); !ok || got != "direct-repo-sessions" {
		t.Fatalf("status.json execution_model = %#v, want %q", status["execution_model"], "direct-repo-sessions")
	}
}