test: block product lower-owner bypasses

Author: nshkrdotcom

support/no_bypass_scanner/README.md

@@ -8,6 +8,13 @@ calls, direct generated SDK calls, direct env auth lookup, direct runtime
 mutation, direct DB access, and direct trace writes in governed workflows. It
 emits ref-only receipts and blocks release when findings remain open.
 
+The structural gate also blocks product code from importing or calling lower
+owner modules directly. Product implementation may call AppKit surfaces and may
+author pure `Mezzanine.Pack` contracts, but product code must not reach into
+Mezzanine workflow/runtime modules, Citadel authority modules, Jido
+Integration, Execution Plane, OuterBrain, GroundPlane, AITrace, TRINITY, GEPA,
+provider SDKs, or generated SDKs for governed behavior.
+
 The foundation gate also protects generic-stack cutovers. In product code, it
 allows provider words in command names, fixtures, docs, packs, receipts, and
 live examples, but flags provider-shaped implementation API names such as

support/no_bypass_scanner/lib/stack_lab/structural_gate_scanner.ex

@@ -124,6 +124,31 @@ defmodule StackLab.StructuralGateScanner do
   ]
   @provider_binding_refs ["linear_primary", "github_primary", "codex_primary"]
 
+  @product_lower_owner_module_prefixes [
+    "AITrace",
+    "Anthropic",
+    "Citadel",
+    "Codex",
+    "ExecutionPlane",
+    "GEPA",
+    "GEPAFramework",
+    "Gepa",
+    "GepaFramework",
+    "GitHubEx",
+    "GroundPlane",
+    "Inference",
+    "Jido",
+    "Jido.Integration",
+    "JidoIntegration",
+    "Linear",
+    "Mezzanine",
+    "OpenAI",
+    "OuterBrain",
+    "ReqLLM",
+    "Trinity",
+    "TrinityFramework"
+  ]
+
   @ground_plane_higher_layer_tokens [
     "AI",
     "ai",
@@ -551,11 +576,19 @@ defmodule StackLab.StructuralGateScanner do
   end
 
   defp ast_node_findings(checked_path, _content, {:alias, meta, [alias_ast]}, _remote?) do
-    {provider_remote_reference_findings(checked_path, meta, alias_ast, :alias), []}
+    findings =
+      provider_remote_reference_findings(checked_path, meta, alias_ast, :alias) ++
+        product_lower_owner_reference_findings(checked_path, meta, alias_ast, :alias)
+
+    {findings, []}
   end
 
   defp ast_node_findings(checked_path, _content, {:import, meta, [alias_ast | _]}, _remote?) do
-    {provider_remote_reference_findings(checked_path, meta, alias_ast, :import), []}
+    findings =
+      provider_remote_reference_findings(checked_path, meta, alias_ast, :import) ++
+        product_lower_owner_reference_findings(checked_path, meta, alias_ast, :import)
+
+    {findings, []}
   end
 
   defp ast_node_findings(
@@ -565,7 +598,11 @@ defmodule StackLab.StructuralGateScanner do
          _remote?
        )
        when is_atom(function_name) do
-    {provider_remote_reference_findings(checked_path, meta, alias_ast, :remote_call), []}
+    findings =
+      provider_remote_reference_findings(checked_path, meta, alias_ast, :remote_call) ++
+        product_lower_owner_reference_findings(checked_path, meta, alias_ast, :remote_call)
+
+    {findings, []}
   end
 
   defp ast_node_findings(checked_path, _content, {:%{}, meta, fields}, _remote?) do
@@ -777,6 +814,52 @@ defmodule StackLab.StructuralGateScanner do
 
   defp provider_remote_reference_findings(_checked_path, _meta, _alias_ast, _role), do: []
 
+  defp product_lower_owner_reference_findings(
+         %CheckedPath{repo: "extravaganza", zone: :product} = checked_path,
+         meta,
+         alias_ast,
+         ast_role
+       ) do
+    alias_text = alias_to_string(alias_ast)
+
+    cond do
+      alias_text == "" ->
+        []
+
+      allowed_product_lower_owner_reference?(alias_text) ->
+        []
+
+      product_lower_owner_reference?(alias_text) ->
+        [
+          finding(checked_path, %{
+            rule: :direct_lower_owner_import_in_product,
+            reason: :product_direct_lower_owner_reference,
+            line: meta_line(meta),
+            token: alias_text,
+            ast_role: ast_role,
+            owner_phase: "Phase 1",
+            remediation:
+              "Product code must enter governed behavior through AppKit surfaces; pure Mezzanine.Pack authoring is the only lower exception."
+          })
+        ]
+
+      true ->
+        []
+    end
+  end
+
+  defp product_lower_owner_reference_findings(_checked_path, _meta, _alias_ast, _role), do: []
+
+  defp product_lower_owner_reference?(alias_text) do
+    Enum.any?(@product_lower_owner_module_prefixes, fn prefix ->
+      alias_text == prefix or String.starts_with?(alias_text, prefix <> ".")
+    end)
+  end
+
+  defp allowed_product_lower_owner_reference?(alias_text) do
+    alias_text == "Mezzanine.Pack" or String.starts_with?(alias_text, "Mezzanine.Pack.")
+  end
+
   defp closed_provider_dispatch_map_findings(checked_path, meta, fields) do
     if Zones.closed_provider_dispatch_scan_path?(checked_path) do
       provider_keys =

support/no_bypass_scanner/test/structural_gate_scanner_test.exs

@@ -141,6 +141,52 @@ defmodule StackLab.StructuralGateScannerTest do
     assert Enum.any?(receipt.findings, &(&1.rule == :provider_shaped_dto_field))
   end
 
+  test "fails product direct imports and calls into lower owner modules", %{roots: roots} do
+    product_path =
+      roots
+      |> Map.fetch!("extravaganza")
+      |> Path.join("apps/extravaganza_core/lib/extravaganza/product_bypass.ex")
+
+    allowed_pack_path =
+      roots
+      |> Map.fetch!("extravaganza")
+      |> Path.join("apps/extravaganza_core/lib/extravaganza/pack_authoring.ex")
+
+    write_file(product_path, """
+    defmodule Extravaganza.ProductBypass do
+      alias Citadel.AuthorityContract
+      import Jido.Integration.V2
+
+      def run(attrs) do
+        Mezzanine.WorkflowRuntime.start(attrs)
+        AITrace.Event.new("bypass")
+        AuthorityContract
+      end
+    end
+    """)
+
+    write_file(allowed_pack_path, """
+    defmodule Extravaganza.PackAuthoring do
+      alias Mezzanine.Pack
+
+      def pack(attrs), do: Pack.new(attrs)
+    end
+    """)
+
+    assert {:ok, receipt} =
+             StructuralGateScanner.scan([product_path, allowed_pack_path], target_roots: roots)
+
+    assert receipt.status == :open_defect
+
+    product_findings = Enum.filter(receipt.findings, &(&1.path == product_path))
+
+    assert Enum.count(product_findings, &(&1.rule == :direct_lower_owner_import_in_product)) >= 2
+    assert Enum.any?(product_findings, &(&1.token == "Mezzanine.WorkflowRuntime"))
+    assert Enum.any?(product_findings, &(&1.token == "AITrace.Event"))
+
+    refute Enum.any?(receipt.findings, &(&1.path == allowed_pack_path))
+  end
+
   test "passes registered generic dispatch proof bundle", %{roots: roots} do
     path =
       roots