@@ -3,6 +3,7 @@ package main
 import (
 	"io/fs"
 	"os"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -14,24 +15,34 @@ import (
 // renders deterministic Kubernetes output from normalized inputs; how that
 // output is transported, reviewed, or reconciled belongs to a separate
 // promotion driver, not here. Each entry is matched case-insensitively.
+//
+// Patterns target the tokens these concepts actually carry in Go source and
+// Kubernetes manifests — import paths, API groups, resource kinds, and
+// process invocations — not the plain-English word, which real integrations
+// never emit. "flux" appears only as "fluxcd" (the module path and the
+// *.toolkit.fluxcd.io API groups); Git integration arrives as the go-git
+// library or an exec of the git binary, never as the prose "git clone".
 var transportOwnershipPatterns = []*regexp.Regexp{
 	regexp.MustCompile(`(?i)gitops`),
 	regexp.MustCompile(`(?i)repourl`),
 	regexp.MustCompile(`(?i)targetrevision`),
 	regexp.MustCompile(`(?i)appproject`),
 	regexp.MustCompile(`(?i)argocd`),
 	regexp.MustCompile(`(?i)argoproj`),
-	regexp.MustCompile(`(?i)\bflux\b`),
+	regexp.MustCompile(`(?i)fluxcd`),
 	regexp.MustCompile(`(?i)kubeconfig`),
 	regexp.MustCompile(`(?i)reconcil`),
+	regexp.MustCompile(`(?i)go-git`),
+	regexp.MustCompile(`(?i)exec\.Command(?:Context)?\([^"]*"git"`),
 	regexp.MustCompile(`(?i)\bgit\s+(clone|push|commit|checkout|fetch|remote|tag|init|pull)\b`),
 	regexp.MustCompile(`(?i)\bpull\s+request\b`),
 	regexp.MustCompile(`(?i)kind:\s*Application\b`),
 	regexp.MustCompile(`(?i)kind:\s*AppProject\b`),
+	regexp.MustCompile(`(?i)kind:\s*GitRepository\b`),
 }
 
-// scan reports every line in content that matches a forbidden pattern,
-// formatted as "<name>:<line>: <trimmed source>".
+// scanTransportOwnership reports every line in content that matches a
+// forbidden pattern, formatted as "<name>:<line>: <trimmed source>".
 func scanTransportOwnership(name, content string) []string {
 	var hits []string
 	for i, line := range strings.Split(content, "\n") {
@@ -45,22 +56,49 @@ func scanTransportOwnership(name, content string) []string {
 	return hits
 }
 
+// isIgnoredSourceDir reports whether a directory is excluded from a module's
+// compiled runtime source. This mirrors the Go toolchain's own rule:
+// directories named "testdata" and those beginning with "." or "_" are never
+// built.
+func isIgnoredSourceDir(name string) bool {
+	return name == "testdata" || strings.HasPrefix(name, ".") || strings.HasPrefix(name, "_")
+}
+
+// runtimeGoFiles returns every compiled runtime Go file under root: all
+// non-test .go files, recursively, excluding toolchain-ignored directories.
+// Test files are excluded because boundary guards (this file included) name
+// the forbidden concepts as data.
+func runtimeGoFiles(root string) ([]string, error) {
+	var files []string
+	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() {
+			if path != root && isIgnoredSourceDir(d.Name()) {
+				return fs.SkipDir
+			}
+			return nil
+		}
+		if strings.HasSuffix(path, ".go") && !strings.HasSuffix(path, "_test.go") {
+			files = append(files, path)
+		}
+		return nil
+	})
+	return files, err
+}
+
 // TestRuntimeSourceIsTransportNeutral enforces the manifest-bundle boundary
 // on this plugin's runtime source: it must not integrate with Git
 // repositories, GitHub/pull requests, Argo CD/Flux reconcilers, kubeconfig,
 // or own reconciliation objects (repoURL, targetRevision, Application,
-// AppProject). Test files are excluded — this guard itself names the
-// forbidden concepts.
+// AppProject). The scan is recursive so a future subpackage cannot escape it.
 func TestRuntimeSourceIsTransportNeutral(t *testing.T) {
-	entries, err := os.ReadDir(".")
+	files, err := runtimeGoFiles(".")
 	if err != nil {
-		t.Fatalf("read package dir: %v", err)
+		t.Fatalf("enumerate runtime source: %v", err)
 	}
-	for _, e := range entries {
-		name := e.Name()
-		if e.IsDir() || !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
-			continue
-		}
+	for _, name := range files {
 		src, err := os.ReadFile(name)
 		if err != nil {
 			t.Fatalf("read %s: %v", name, err)
@@ -73,8 +111,8 @@ func TestRuntimeSourceIsTransportNeutral(t *testing.T) {
 
 // TestOwnedManifestsAreTransportNeutral enforces the same boundary on the
 // plugin-owned deployment templates: they carry only workload/resources,
-// never reconciliation control-plane objects (Argo Application/AppProject)
-// or repository source bindings (repoURL, targetRevision).
+// never reconciliation control-plane objects (Argo Application/AppProject,
+// Flux GitRepository) or repository source bindings (repoURL, targetRevision).
 func TestOwnedManifestsAreTransportNeutral(t *testing.T) {
 	err := fs.WalkDir(deploymentFS, ".", func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
@@ -96,3 +134,85 @@ func TestOwnedManifestsAreTransportNeutral(t *testing.T) {
 		t.Fatalf("walk deployment templates: %v", err)
 	}
 }
+
+// TestScanTransportOwnershipDetectsRealVectors pins the detector to the forms
+// transport ownership actually takes in Go source and manifests — library
+// imports, API groups, resource kinds, and process invocations — and to a set
+// of benign lines that must not trip it.
+func TestScanTransportOwnershipDetectsRealVectors(t *testing.T) {
+	forbidden := []string{
+		`_ "github.com/fluxcd/pkg/apis/meta"`,
+		`apiVersion: source.toolkit.fluxcd.io/v1`,
+		`kind: GitRepository`,
+		`_ "github.com/argoproj/argo-cd/v2/pkg/apis"`,
+		`import gogit "github.com/go-git/go-git/v5"`,
+		`r, _ := exec.Command("git", "clone", url).Output()`,
+		`out, _ := exec.CommandContext(ctx, "git", "push").CombinedOutput()`,
+		`kind: Application`,
+		`spec: { repoURL: https://example.com, targetRevision: main }`,
+		`// reconcile the cluster state`,
+	}
+	for _, line := range forbidden {
+		if hits := scanTransportOwnership("x.go", line); hits == nil {
+			t.Errorf("expected forbidden line to be flagged: %q", line)
+		}
+	}
+
+	benign := []string{
+		`import _ "github.com/codefly-dev/core/agents/services"`,
+		`s.Wool.Debug("git status is clean")`,
+		`kind: Deployment`,
+		`kind: Service`,
+		`newTag: {{.Image.Tag}}`,
+		`// influx of requests handled by the digit parser`,
+	}
+	for _, line := range benign {
+		if hits := scanTransportOwnership("x.go", line); hits != nil {
+			t.Errorf("benign line falsely flagged: %q -> %v", line, hits)
+		}
+	}
+}
+
+// TestRuntimeGoFilesRecursesAndFilters proves the enumerator descends into
+// subpackages (so no future package escapes the boundary check) while
+// excluding test files and toolchain-ignored directories.
+func TestRuntimeGoFilesRecursesAndFilters(t *testing.T) {
+	root := t.TempDir()
+	write := func(rel string) {
+		p := filepath.Join(root, rel)
+		if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(p, []byte("package p\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("top.go")
+	write("sub/pkg/deep.go")
+	write("sub/pkg/deep_test.go")
+	write("testdata/fixture.go")
+	write(".hidden/skip.go")
+
+	files, err := runtimeGoFiles(root)
+	if err != nil {
+		t.Fatalf("runtimeGoFiles: %v", err)
+	}
+	got := map[string]bool{}
+	for _, f := range files {
+		rel, _ := filepath.Rel(root, f)
+		got[filepath.ToSlash(rel)] = true
+	}
+
+	want := []string{"top.go", "sub/pkg/deep.go"}
+	for _, w := range want {
+		if !got[w] {
+			t.Errorf("expected %s to be scanned, got %v", w, files)
+		}
+	}
+	excluded := []string{"sub/pkg/deep_test.go", "testdata/fixture.go", ".hidden/skip.go"}
+	for _, e := range excluded {
+		if got[e] {
+			t.Errorf("%s should have been excluded from the scan", e)
+		}
+	}
+}